Sema.h source code [llvm/clang/include/clang/Sema/Sema.h]

1	//===--- Sema.h - Semantic Analysis & AST Building --------------- C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file defines the Sema class, which performs semantic analysis and
10	// builds ASTs.
11	//
12	//===----------------------------------------------------------------------===//
13
14	#ifndef LLVM_CLANG_SEMA_SEMA_H
15	#define LLVM_CLANG_SEMA_SEMA_H
16
17	#include "clang/AST/ASTConcept.h"
18	#include "clang/AST/ASTFwd.h"
19	#include "clang/AST/Attr.h"
20	#include "clang/AST/Availability.h"
21	#include "clang/AST/ComparisonCategories.h"
22	#include "clang/AST/DeclTemplate.h"
23	#include "clang/AST/DeclarationName.h"
24	#include "clang/AST/Expr.h"
25	#include "clang/AST/ExprCXX.h"
26	#include "clang/AST/ExprConcepts.h"
27	#include "clang/AST/ExprObjC.h"
28	#include "clang/AST/ExprOpenMP.h"
29	#include "clang/AST/ExternalASTSource.h"
30	#include "clang/AST/LocInfoType.h"
31	#include "clang/AST/MangleNumberingContext.h"
32	#include "clang/AST/NSAPI.h"
33	#include "clang/AST/PrettyPrinter.h"
34	#include "clang/AST/StmtCXX.h"
35	#include "clang/AST/TypeLoc.h"
36	#include "clang/AST/TypeOrdering.h"
37	#include "clang/Basic/BitmaskEnum.h"
38	#include "clang/Basic/ExpressionTraits.h"
39	#include "clang/Basic/Module.h"
40	#include "clang/Basic/OpenCLOptions.h"
41	#include "clang/Basic/OpenMPKinds.h"
42	#include "clang/Basic/PragmaKinds.h"
43	#include "clang/Basic/Specifiers.h"
44	#include "clang/Basic/TemplateKinds.h"
45	#include "clang/Basic/TypeTraits.h"
46	#include "clang/Sema/AnalysisBasedWarnings.h"
47	#include "clang/Sema/CleanupInfo.h"
48	#include "clang/Sema/DeclSpec.h"
49	#include "clang/Sema/ExternalSemaSource.h"
50	#include "clang/Sema/IdentifierResolver.h"
51	#include "clang/Sema/ObjCMethodList.h"
52	#include "clang/Sema/Ownership.h"
53	#include "clang/Sema/Scope.h"
54	#include "clang/Sema/SemaConcept.h"
55	#include "clang/Sema/TypoCorrection.h"
56	#include "clang/Sema/Weak.h"
57	#include "llvm/ADT/ArrayRef.h"
58	#include "llvm/ADT/Optional.h"
59	#include "llvm/ADT/SetVector.h"
60	#include "llvm/ADT/SmallBitVector.h"
61	#include "llvm/ADT/SmallPtrSet.h"
62	#include "llvm/ADT/SmallSet.h"
63	#include "llvm/ADT/SmallVector.h"
64	#include "llvm/ADT/TinyPtrVector.h"
65	#include "llvm/Frontend/OpenMP/OMPConstants.h"
66	#include <deque>
67	#include <memory>
68	#include <string>
69	#include <tuple>
70	#include <vector>
71
72	namespace llvm {
73	class APSInt;
74	template <typename ValueT> struct DenseMapInfo;
75	template <typename ValueT, typename ValueInfoT> class DenseSet;
76	class SmallBitVector;
77	struct InlineAsmIdentifierInfo;
78	}
79
80	namespace clang {
81	class ADLResult;
82	class ASTConsumer;
83	class ASTContext;
84	class ASTMutationListener;
85	class ASTReader;
86	class ASTWriter;
87	class ArrayType;
88	class ParsedAttr;
89	class BindingDecl;
90	class BlockDecl;
91	class CapturedDecl;
92	class CXXBasePath;
93	class CXXBasePaths;
94	class CXXBindTemporaryExpr;
95	typedef SmallVector<CXXBaseSpecifier*, `4`> CXXCastPath;
96	class CXXConstructorDecl;
97	class CXXConversionDecl;
98	class CXXDeleteExpr;
99	class CXXDestructorDecl;
100	class CXXFieldCollector;
101	class CXXMemberCallExpr;
102	class CXXMethodDecl;
103	class CXXScopeSpec;
104	class CXXTemporary;
105	class CXXTryStmt;
106	class CallExpr;
107	class ClassTemplateDecl;
108	class ClassTemplatePartialSpecializationDecl;
109	class ClassTemplateSpecializationDecl;
110	class VarTemplatePartialSpecializationDecl;
111	class CodeCompleteConsumer;
112	class CodeCompletionAllocator;
113	class CodeCompletionTUInfo;
114	class CodeCompletionResult;
115	class CoroutineBodyStmt;
116	class Decl;
117	class DeclAccessPair;
118	class DeclContext;
119	class DeclRefExpr;
120	class DeclaratorDecl;
121	class DeducedTemplateArgument;
122	class DependentDiagnostic;
123	class DesignatedInitExpr;
124	class Designation;
125	class EnableIfAttr;
126	class EnumConstantDecl;
127	class Expr;
128	class ExtVectorType;
129	class FormatAttr;
130	class FriendDecl;
131	class FunctionDecl;
132	class FunctionProtoType;
133	class FunctionTemplateDecl;
134	class ImplicitConversionSequence;
135	typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
136	class InitListExpr;
137	class InitializationKind;
138	class InitializationSequence;
139	class InitializedEntity;
140	class IntegerLiteral;
141	class LabelStmt;
142	class LambdaExpr;
143	class LangOptions;
144	class LocalInstantiationScope;
145	class LookupResult;
146	class MacroInfo;
147	typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
148	class ModuleLoader;
149	class MultiLevelTemplateArgumentList;
150	class NamedDecl;
151	class ObjCCategoryDecl;
152	class ObjCCategoryImplDecl;
153	class ObjCCompatibleAliasDecl;
154	class ObjCContainerDecl;
155	class ObjCImplDecl;
156	class ObjCImplementationDecl;
157	class ObjCInterfaceDecl;
158	class ObjCIvarDecl;
159	template <class T> class ObjCList;
160	class ObjCMessageExpr;
161	class ObjCMethodDecl;
162	class ObjCPropertyDecl;
163	class ObjCProtocolDecl;
164	class OMPThreadPrivateDecl;
165	class OMPRequiresDecl;
166	class OMPDeclareReductionDecl;
167	class OMPDeclareSimdDecl;
168	class OMPClause;
169	struct OMPVarListLocTy;
170	struct OverloadCandidate;
171	enum class OverloadCandidateParamOrder : char;
172	enum OverloadCandidateRewriteKind : unsigned;
173	class OverloadCandidateSet;
174	class OverloadExpr;
175	class ParenListExpr;
176	class ParmVarDecl;
177	class Preprocessor;
178	class PseudoDestructorTypeStorage;
179	class PseudoObjectExpr;
180	class QualType;
181	class StandardConversionSequence;
182	class Stmt;
183	class StringLiteral;
184	class SwitchStmt;
185	class TemplateArgument;
186	class TemplateArgumentList;
187	class TemplateArgumentLoc;
188	class TemplateDecl;
189	class TemplateInstantiationCallback;
190	class TemplateParameterList;
191	class TemplatePartialOrderingContext;
192	class TemplateTemplateParmDecl;
193	class Token;
194	class TypeAliasDecl;
195	class TypedefDecl;
196	class TypedefNameDecl;
197	class TypeLoc;
198	class TypoCorrectionConsumer;
199	class UnqualifiedId;
200	class UnresolvedLookupExpr;
201	class UnresolvedMemberExpr;
202	class UnresolvedSetImpl;
203	class UnresolvedSetIterator;
204	class UsingDecl;
205	class UsingShadowDecl;
206	class ValueDecl;
207	class VarDecl;
208	class VarTemplateSpecializationDecl;
209	class VisibilityAttr;
210	class VisibleDeclConsumer;
211	class IndirectFieldDecl;
212	struct DeductionFailureInfo;
213	class TemplateSpecCandidateSet;
214
215	namespace sema {
216	class AccessedEntity;
217	class BlockScopeInfo;
218	class Capture;
219	class CapturedRegionScopeInfo;
220	class CapturingScopeInfo;
221	class CompoundScopeInfo;
222	class DelayedDiagnostic;
223	class DelayedDiagnosticPool;
224	class FunctionScopeInfo;
225	class LambdaScopeInfo;
226	class PossiblyUnreachableDiag;
227	class SemaPPCallbacks;
228	class TemplateDeductionInfo;
229	}
230
231	namespace threadSafety {
232	class BeforeSet;
233	void threadSafetyCleanup(BeforeSet* Cache);
234	}
235
236	// FIXME: No way to easily map from TemplateTypeParmTypes to
237	// TemplateTypeParmDecls, so we have this horrible PointerUnion.
238	typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType, NamedDecl>,
239	SourceLocation> UnexpandedParameterPack;
240
241	/// Describes whether we've seen any nullability information for the given
242	/// file.
243	struct FileNullability {
244	/// The first pointer declarator (of any pointer kind) in the file that does
245	/// not have a corresponding nullability annotation.
246	SourceLocation PointerLoc;
247
248	/// The end location for the first pointer declarator in the file. Used for
249	/// placing fix-its.
250	SourceLocation PointerEndLoc;
251
252	/// Which kind of pointer declarator we saw.
253	uint8_t PointerKind;
254
255	/// Whether we saw any type nullability annotations in the given file.
256	bool SawTypeNullability = false;
257	};
258
259	/// A mapping from file IDs to a record of whether we've seen nullability
260	/// information in that file.
261	class FileNullabilityMap {
262	/// A mapping from file IDs to the nullability information for each file ID.
263	llvm::DenseMap<FileID, FileNullability> Map;
264
265	/// A single-element cache based on the file ID.
266	struct {
267	FileID File;
268	FileNullability Nullability;
269	} Cache;
270
271	public:
272	FileNullability &operator[](FileID file) {
273	// Check the single-element cache.
274	if (file == Cache.File)
275	return Cache.Nullability;
276
277	// It's not in the single-element cache; flush the cache if we have one.
278	if (!Cache.File.isInvalid()) {
279	Map [Cache.File] = Cache.Nullability;
280	}
281
282	// Pull this entry into the cache.
283	Cache.File = file;
284	Cache.Nullability = Map [file];
285	return Cache.Nullability;
286	}
287	};
288
289	/// Keeps track of expected type during expression parsing. The type is tied to
290	/// a particular token, all functions that update or consume the type take a
291	/// start location of the token they are looking at as a parameter. This allows
292	/// to avoid updating the type on hot paths in the parser.
293	class PreferredTypeBuilder {
294	public:
295	PreferredTypeBuilder() = default;
296	explicit PreferredTypeBuilder(QualType Type) : Type (Type) {}
297
298	void enterCondition(Sema &S, SourceLocation Tok);
299	void enterReturn(Sema &S, SourceLocation Tok);
300	void enterVariableInit(SourceLocation Tok, Decl *D);
301	/// Computing a type for the function argument may require running
302	/// overloading, so we postpone its computation until it is actually needed.
303	///
304	/// Clients should be very careful when using this funciton, as it stores a
305	/// function_ref, clients should make sure all calls to get() with the same
306	/// location happen while function_ref is alive.
307	void enterFunctionArgument(SourceLocation Tok,
308	llvm::function_ref<QualType()> ComputeType);
309
310	void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc);
311	void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind,
312	SourceLocation OpLoc);
313	void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op);
314	void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base);
315	void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS);
316	/// Handles all type casts, including C-style cast, C++ casts, etc.
317	void enterTypeCast(SourceLocation Tok, QualType CastType);
318
319	QualType get(SourceLocation Tok) const {
320	if (Tok != ExpectedLoc)
321	return QualType ();
322	if (!Type.isNull())
323	return Type;
324	if (ComputeType)
325	return ComputeType ();
326	return QualType ();
327	}
328
329	private:
330	/// Start position of a token for which we store expected type.
331	SourceLocation ExpectedLoc;
332	/// Expected type for a token starting at ExpectedLoc.
333	QualType Type;
334	/// A function to compute expected type at ExpectedLoc. It is only considered
335	/// if Type is null.
336	llvm::function_ref<QualType()> ComputeType;
337	};
338
339	/// Sema - This implements semantic analysis and AST building for C.
340	class Sema final {
341	Sema(const Sema &) = delete;
342	void operator=(const Sema &) = delete;
343
344	/// A key method to reduce duplicate debug info from Sema.
345	virtual void anchor();
346
347	///Source of additional semantic information.
348	ExternalSemaSource *ExternalSource;
349
350	///Whether Sema has generated a multiplexer and has to delete it.
351	bool isMultiplexExternalSource;
352
353	static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
354
355	bool isVisibleSlow(const NamedDecl *D);
356
357	/// Determine whether two declarations should be linked together, given that
358	/// the old declaration might not be visible and the new declaration might
359	/// not have external linkage.
360	bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
361	const NamedDecl *New) {
362	if (isVisible(Old))
363	return true;
364	// See comment in below overload for why it's safe to compute the linkage
365	// of the new declaration here.
366	if (New->isExternallyDeclarable()) {
367	assert(Old->isExternallyDeclarable() &&
368	"should not have found a non-externally-declarable previous decl");
369	return true;
370	}
371	return false;
372	}
373	bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
374
375	void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
376	QualType ResultTy,
377	ArrayRef<QualType> Args);
378
379	public:
380	/// The maximum alignment, same as in llvm::Value. We duplicate them here
381	/// because that allows us not to duplicate the constants in clang code,
382	/// which we must to since we can't directly use the llvm constants.
383	/// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp
384	///
385	/// This is the greatest alignment value supported by load, store, and alloca
386	/// instructions, and global values.
387	static const unsigned MaxAlignmentExponent = `29`;
388	static const unsigned MaximumAlignment = `1u` << MaxAlignmentExponent;
389
390	typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
391	typedef OpaquePtr<TemplateName> TemplateTy;
392	typedef OpaquePtr<QualType> TypeTy;
393
394	OpenCLOptions OpenCLFeatures;
395	FPOptions CurFPFeatures;
396
397	const LangOptions &LangOpts;
398	Preprocessor &PP;
399	ASTContext &Context;
400	ASTConsumer &Consumer;
401	DiagnosticsEngine &Diags;
402	SourceManager &SourceMgr;
403
404	/// Flag indicating whether or not to collect detailed statistics.
405	bool CollectStats;
406
407	/// Code-completion consumer.
408	CodeCompleteConsumer *CodeCompleter;
409
410	/// CurContext - This is the current declaration context of parsing.
411	DeclContext *CurContext;
412
413	/// Generally null except when we temporarily switch decl contexts,
414	/// like in \see ActOnObjCTemporaryExitContainerContext.
415	DeclContext *OriginalLexicalContext;
416
417	/// VAListTagName - The declaration name corresponding to __va_list_tag.
418	/// This is used as part of a hack to omit that class from ADL results.
419	DeclarationName VAListTagName;
420
421	bool MSStructPragmaOn; // True when \#pragma ms_struct on
422
423	/// Controls member pointer representation format under the MS ABI.
424	LangOptions::PragmaMSPointersToMembersKind
425	MSPointerToMemberRepresentationMethod;
426
427	/// Stack of active SEH __finally scopes. Can be empty.
428	SmallVector<Scope*, `2`> CurrentSEHFinally;
429
430	/// Source location for newly created implicit MSInheritanceAttrs
431	SourceLocation ImplicitMSInheritanceAttrLoc;
432
433	/// Holds TypoExprs that are created from `createDelayedTypo`. This is used by
434	/// `TransformTypos` in order to keep track of any TypoExprs that are created
435	/// recursively during typo correction and wipe them away if the correction
436	/// fails.
437	llvm::SmallVector<TypoExpr *, `2`> TypoExprs;
438
439	/// pragma clang section kind
440	enum PragmaClangSectionKind {
441	PCSK_Invalid = `0`,
442	PCSK_BSS = `1`,
443	PCSK_Data = `2`,
444	PCSK_Rodata = `3`,
445	PCSK_Text = `4`,
446	PCSK_Relro = `5`
447	};
448
449	enum PragmaClangSectionAction {
450	PCSA_Set = `0`,
451	PCSA_Clear = `1`
452	};
453
454	struct PragmaClangSection {
455	std::string SectionName;
456	bool Valid = false;
457	SourceLocation PragmaLocation;
458	};
459
460	PragmaClangSection PragmaClangBSSSection;
461	PragmaClangSection PragmaClangDataSection;
462	PragmaClangSection PragmaClangRodataSection;
463	PragmaClangSection PragmaClangRelroSection;
464	PragmaClangSection PragmaClangTextSection;
465
466	enum PragmaMsStackAction {
467	PSK_Reset = `0x0`, // #pragma ()
468	PSK_Set = `0x1`, // #pragma (value)
469	PSK_Push = `0x2`, // #pragma (push[, id])
470	PSK_Pop = `0x4`, // #pragma (pop[, id])
471	PSK_Show = `0x8`, // #pragma (show) -- only for "pack"!
472	PSK_Push_Set = PSK_Push \| PSK_Set, // #pragma (push[, id], value)
473	PSK_Pop_Set = PSK_Pop \| PSK_Set, // #pragma (pop[, id], value)
474	};
475
476	// #pragma pack and align.
477	class AlignPackInfo {
478	public:
479	// `Native` represents default align mode, which may vary based on the
480	// platform.
481	enum Mode : unsigned char { Native, Natural, Packed, Mac68k };
482
483	// #pragma pack info constructor
484	AlignPackInfo(AlignPackInfo::Mode M, unsigned Num, bool IsXL)
485	: PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) {
486	assert(Num == PackNumber && "The pack number has been truncated.");
487	}
488
489	// #pragma align info constructor
490	AlignPackInfo(AlignPackInfo::Mode M, bool IsXL)
491	: PackAttr(false), AlignMode(M),
492	PackNumber(M == Packed ? `1` : UninitPackVal), XLStack(IsXL) {}
493
494	explicit AlignPackInfo(bool IsXL) : AlignPackInfo (Native, IsXL) {}
495
496	AlignPackInfo() : AlignPackInfo (Native, false) {}
497
498	// When a AlignPackInfo itself cannot be used, this returns an 32-bit
499	// integer encoding for it. This should only be passed to
500	// AlignPackInfo::getFromRawEncoding, it should not be inspected directly.
501	static uint32_t getRawEncoding(const AlignPackInfo &Info) {
502	std::uint32_t Encoding{};
503	if (Info.IsXLStack())
504	Encoding \|= IsXLMask;
505
506	Encoding \|= static_cast<uint32_t>(Info.getAlignMode()) << `1`;
507
508	if (Info.IsPackAttr())
509	Encoding \|= PackAttrMask;
510
511	Encoding \|= static_cast<uint32_t>(Info.getPackNumber()) << `4`;
512
513	return Encoding;
514	}
515
516	static AlignPackInfo getFromRawEncoding(unsigned Encoding) {
517	bool IsXL = static_cast<bool>(Encoding & IsXLMask);
518	AlignPackInfo::Mode M =
519	static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> `1`);
520	int PackNumber = (Encoding & PackNumMask) >> `4`;
521
522	if (Encoding & PackAttrMask)
523	return AlignPackInfo (M, PackNumber, IsXL);
524
525	return AlignPackInfo (M, IsXL);
526	}
527
528	bool IsPackAttr() const { return PackAttr; }
529
530	bool IsAlignAttr() const { return !PackAttr; }
531
532	Mode getAlignMode() const { return AlignMode; }
533
534	unsigned getPackNumber() const { return PackNumber; }
535
536	bool IsPackSet() const {
537	// #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack
538	// attriute on a decl.
539	return PackNumber != UninitPackVal && PackNumber != `0`;
540	}
541
542	bool IsXLStack() const { return XLStack; }
543
544	bool operator==(const AlignPackInfo &Info) const {
545	return std::tie(AlignMode, PackNumber, PackAttr, XLStack) ==
546	std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr,
547	Info.XLStack);
548	}
549
550	bool operator!=(const AlignPackInfo &Info) const {
551	return !(*this == Info);
552	}
553
554	private:
555	/// \brief True if this is a pragma pack attribute,
556	/// not a pragma align attribute.
557	bool PackAttr;
558
559	/// \brief The alignment mode that is in effect.
560	Mode AlignMode;
561
562	/// \brief The pack number of the stack.
563	unsigned char PackNumber;
564
565	/// \brief True if it is a XL #pragma align/pack stack.
566	bool XLStack;
567
568	/// \brief Uninitialized pack value.
569	static constexpr unsigned char UninitPackVal = -`1`;
570
571	// Masks to encode and decode an AlignPackInfo.
572	static constexpr uint32_t IsXLMask{`0x0000'0001`};
573	static constexpr uint32_t AlignModeMask{`0x0000'0006`};
574	static constexpr uint32_t PackAttrMask{`0x00000'0008`};
575	static constexpr uint32_t PackNumMask{`0x0000'01F0`};
576	};
577
578	template<typename ValueType>
579	struct PragmaStack {
580	struct Slot {
581	llvm::StringRef StackSlotLabel;
582	ValueType Value;
583	SourceLocation PragmaLocation;
584	SourceLocation PragmaPushLocation;
585	Slot(llvm::StringRef StackSlotLabel, ValueType Value,
586	SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
587	: StackSlotLabel (StackSlotLabel), Value(Value),
588	PragmaLocation (PragmaLocation),
589	PragmaPushLocation (PragmaPushLocation) {}
590	};
591
592	void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action,
593	llvm::StringRef StackSlotLabel, ValueType Value) {
594	if (Action == PSK_Reset) {
595	CurrentValue = DefaultValue;
596	CurrentPragmaLocation = PragmaLocation;
597	return;
598	}
599	if (Action & PSK_Push)
600	Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
601	PragmaLocation);
602	else if (Action & PSK_Pop) {
603	if (!StackSlotLabel.empty()) {
604	// If we've got a label, try to find it and jump there.
605	auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
606	return x.StackSlotLabel == StackSlotLabel;
607	});
608	// If we found the label so pop from there.
609	if (I != Stack.rend()) {
610	CurrentValue = I->Value;
611	CurrentPragmaLocation = I->PragmaLocation;
612	Stack.erase(std::prev(I.base()), Stack.end());
613	}
614	} else if (!Stack.empty()) {
615	// We do not have a label, just pop the last entry.
616	CurrentValue = Stack.back().Value;
617	CurrentPragmaLocation = Stack.back().PragmaLocation;
618	Stack.pop_back();
619	}
620	}
621	if (Action & PSK_Set) {
622	CurrentValue = Value;
623	CurrentPragmaLocation = PragmaLocation;
624	}
625	}
626
627	// MSVC seems to add artificial slots to #pragma stacks on entering a C++
628	// method body to restore the stacks on exit, so it works like this:
629	//
630	// struct S {
631	// #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
632	// void Method {}
633	// #pragma <name>(pop, InternalPragmaSlot)
634	// };
635	//
636	// It works even with #pragma vtordisp, although MSVC doesn't support
637	// #pragma vtordisp(push [, id], n)
638	// syntax.
639	//
640	// Push / pop a named sentinel slot.
641	void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
642	assert((Action == PSK_Push \|\| Action == PSK_Pop) &&
643	"Can only push / pop #pragma stack sentinels!");
644	Act(CurrentPragmaLocation, Action, Label, CurrentValue);
645	}
646
647	// Constructors.
648	explicit PragmaStack(const ValueType &Default)
649	: DefaultValue(Default), CurrentValue(Default) {}
650
651	bool hasValue() const { return CurrentValue != DefaultValue; }
652
653	SmallVector<Slot, `2`> Stack;
654	ValueType DefaultValue; // Value used for PSK_Reset action.
655	ValueType CurrentValue;
656	SourceLocation CurrentPragmaLocation;
657	};
658	// FIXME: We should serialize / deserialize these if they occur in a PCH (but
659	// we shouldn't do so if they're in a module).
660
661	/// Whether to insert vtordisps prior to virtual bases in the Microsoft
662	/// C++ ABI. Possible values are 0, 1, and 2, which mean:
663	///
664	/// 0: Suppress all vtordisps
665	/// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
666	/// structors
667	/// 2: Always insert vtordisps to support RTTI on partially constructed
668	/// objects
669	PragmaStack<MSVtorDispMode> VtorDispStack;
670	PragmaStack<AlignPackInfo> AlignPackStack;
671	// The current #pragma align/pack values and locations at each #include.
672	struct AlignPackIncludeState {
673	AlignPackInfo CurrentValue;
674	SourceLocation CurrentPragmaLocation;
675	bool HasNonDefaultValue, ShouldWarnOnInclude;
676	};
677	SmallVector<AlignPackIncludeState, `8`> AlignPackIncludeStack;
678	// Segment #pragmas.
679	PragmaStack<StringLiteral *> DataSegStack;
680	PragmaStack<StringLiteral *> BSSSegStack;
681	PragmaStack<StringLiteral *> ConstSegStack;
682	PragmaStack<StringLiteral *> CodeSegStack;
683
684	// This stack tracks the current state of Sema.CurFPFeatures.
685	PragmaStack<FPOptionsOverride> FpPragmaStack;
686	FPOptionsOverride CurFPFeatureOverrides() {
687	FPOptionsOverride result;
688	if (!FpPragmaStack.hasValue()) {
689	result = FPOptionsOverride ();
690	} else {
691	result = FpPragmaStack.CurrentValue;
692	}
693	return result;
694	}
695
696	// RAII object to push / pop sentinel slots for all MS #pragma stacks.
697	// Actions should be performed only if we enter / exit a C++ method body.
698	class PragmaStackSentinelRAII {
699	public:
700	PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
701	~PragmaStackSentinelRAII();
702
703	private:
704	Sema &S;
705	StringRef SlotLabel;
706	bool ShouldAct;
707	};
708
709	/// A mapping that describes the nullability we've seen in each header file.
710	FileNullabilityMap NullabilityMap;
711
712	/// Last section used with #pragma init_seg.
713	StringLiteral *CurInitSeg;
714	SourceLocation CurInitSegLoc;
715
716	/// VisContext - Manages the stack for \#pragma GCC visibility.
717	void VisContext; // Really a "PragmaVisStack"
718
719	/// This an attribute introduced by \#pragma clang attribute.
720	struct PragmaAttributeEntry {
721	SourceLocation Loc;
722	ParsedAttr *Attribute;
723	SmallVector<attr::SubjectMatchRule, `4`> MatchRules;
724	bool IsUsed;
725	};
726
727	/// A push'd group of PragmaAttributeEntries.
728	struct PragmaAttributeGroup {
729	/// The location of the push attribute.
730	SourceLocation Loc;
731	/// The namespace of this push group.
732	const IdentifierInfo *Namespace;
733	SmallVector<PragmaAttributeEntry, `2`> Entries;
734	};
735
736	SmallVector<PragmaAttributeGroup, `2`> PragmaAttributeStack;
737
738	/// The declaration that is currently receiving an attribute from the
739	/// #pragma attribute stack.
740	const Decl *PragmaAttributeCurrentTargetDecl;
741
742	/// This represents the last location of a "#pragma clang optimize off"
743	/// directive if such a directive has not been closed by an "on" yet. If
744	/// optimizations are currently "on", this is set to an invalid location.
745	SourceLocation OptimizeOffPragmaLocation;
746
747	/// Flag indicating if Sema is building a recovery call expression.
748	///
749	/// This flag is used to avoid building recovery call expressions
750	/// if Sema is already doing so, which would cause infinite recursions.
751	bool IsBuildingRecoveryCallExpr;
752
753	/// Used to control the generation of ExprWithCleanups.
754	CleanupInfo Cleanup;
755
756	/// ExprCleanupObjects - This is the stack of objects requiring
757	/// cleanup that are created by the current full expression.
758	SmallVector<ExprWithCleanups::CleanupObject, `8`> ExprCleanupObjects;
759
760	/// Store a set of either DeclRefExprs or MemberExprs that contain a reference
761	/// to a variable (constant) that may or may not be odr-used in this Expr, and
762	/// we won't know until all lvalue-to-rvalue and discarded value conversions
763	/// have been applied to all subexpressions of the enclosing full expression.
764	/// This is cleared at the end of each full expression.
765	using MaybeODRUseExprSet = llvm::SetVector<Expr , SmallVector<Expr , `4`>,
766	llvm::SmallPtrSet<Expr *, `4`>>;
767	MaybeODRUseExprSet MaybeODRUseExprs;
768
769	std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope;
770
771	/// Stack containing information about each of the nested
772	/// function, block, and method scopes that are currently active.
773	SmallVector<sema::FunctionScopeInfo *, `4`> FunctionScopes;
774
775	/// The index of the first FunctionScope that corresponds to the current
776	/// context.
777	unsigned FunctionScopesStart = `0`;
778
779	ArrayRef<sema::FunctionScopeInfo> getFunctionScopes() const* {
780	return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart,
781	FunctionScopes.end());
782	}
783
784	/// Stack containing information needed when in C++2a an 'auto' is encountered
785	/// in a function declaration parameter type specifier in order to invent a
786	/// corresponding template parameter in the enclosing abbreviated function
787	/// template. This information is also present in LambdaScopeInfo, stored in
788	/// the FunctionScopes stack.
789	SmallVector<InventedTemplateParameterInfo, `4`> InventedParameterInfos;
790
791	/// The index of the first InventedParameterInfo that refers to the current
792	/// context.
793	unsigned InventedParameterInfosStart = `0`;
794
795	ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const {
796	return llvm::makeArrayRef(InventedParameterInfos.begin() +
797	InventedParameterInfosStart,
798	InventedParameterInfos.end());
799	}
800
801	typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
802	&ExternalSemaSource::ReadExtVectorDecls, `2`, `2`>
803	ExtVectorDeclsType;
804
805	/// ExtVectorDecls - This is a list all the extended vector types. This allows
806	/// us to associate a raw vector type with one of the ext_vector type names.
807	/// This is only necessary for issuing pretty diagnostics.
808	ExtVectorDeclsType ExtVectorDecls;
809
810	/// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
811	std::unique_ptr<CXXFieldCollector> FieldCollector;
812
813	typedef llvm::SmallSetVector<NamedDecl *, `16`> NamedDeclSetType;
814
815	/// Set containing all declared private fields that are not used.
816	NamedDeclSetType UnusedPrivateFields;
817
818	/// Set containing all typedefs that are likely unused.
819	llvm::SmallSetVector<const TypedefNameDecl *, `4`>
820	UnusedLocalTypedefNameCandidates;
821
822	/// Delete-expressions to be analyzed at the end of translation unit
823	///
824	/// This list contains class members, and locations of delete-expressions
825	/// that could not be proven as to whether they mismatch with new-expression
826	/// used in initializer of the field.
827	typedef std::pair<SourceLocation, bool> DeleteExprLoc;
828	typedef llvm::SmallVector<DeleteExprLoc, `4`> DeleteLocs;
829	llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
830
831	typedef llvm::SmallPtrSet<const CXXRecordDecl*, `8`> RecordDeclSetTy;
832
833	/// PureVirtualClassDiagSet - a set of class declarations which we have
834	/// emitted a list of pure virtual functions. Used to prevent emitting the
835	/// same list more than once.
836	std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
837
838	/// ParsingInitForAutoVars - a set of declarations with auto types for which
839	/// we are currently parsing the initializer.
840	llvm::SmallPtrSet<const Decl*, `4`> ParsingInitForAutoVars;
841
842	/// Look for a locally scoped extern "C" declaration by the given name.
843	NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
844
845	typedef LazyVector<VarDecl *, ExternalSemaSource,
846	&ExternalSemaSource::ReadTentativeDefinitions, `2`, `2`>
847	TentativeDefinitionsType;
848
849	/// All the tentative definitions encountered in the TU.
850	TentativeDefinitionsType TentativeDefinitions;
851
852	/// All the external declarations encoutered and used in the TU.
853	SmallVector<VarDecl *, `4`> ExternalDeclarations;
854
855	typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
856	&ExternalSemaSource::ReadUnusedFileScopedDecls, `2`, `2`>
857	UnusedFileScopedDeclsType;
858
859	/// The set of file scoped decls seen so far that have not been used
860	/// and must warn if not used. Only contains the first declaration.
861	UnusedFileScopedDeclsType UnusedFileScopedDecls;
862
863	typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
864	&ExternalSemaSource::ReadDelegatingConstructors, `2`, `2`>
865	DelegatingCtorDeclsType;
866
867	/// All the delegating constructors seen so far in the file, used for
868	/// cycle detection at the end of the TU.
869	DelegatingCtorDeclsType DelegatingCtorDecls;
870
871	/// All the overriding functions seen during a class definition
872	/// that had their exception spec checks delayed, plus the overridden
873	/// function.
874	SmallVector<std::pair<const CXXMethodDecl, const* CXXMethodDecl*>, `2`>
875	DelayedOverridingExceptionSpecChecks;
876
877	/// All the function redeclarations seen during a class definition that had
878	/// their exception spec checks delayed, plus the prior declaration they
879	/// should be checked against. Except during error recovery, the new decl
880	/// should always be a friend declaration, as that's the only valid way to
881	/// redeclare a special member before its class is complete.
882	SmallVector<std::pair<FunctionDecl, FunctionDecl>, `2`>
883	DelayedEquivalentExceptionSpecChecks;
884
885	typedef llvm::MapVector<const FunctionDecl *,
886	std::unique_ptr<LateParsedTemplate>>
887	LateParsedTemplateMapT;
888	LateParsedTemplateMapT LateParsedTemplateMap;
889
890	/// Callback to the parser to parse templated functions when needed.
891	typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
892	typedef void LateTemplateParserCleanupCB(void *P);
893	LateTemplateParserCB *LateTemplateParser;
894	LateTemplateParserCleanupCB *LateTemplateParserCleanup;
895	void *OpaqueParser;
896
897	void SetLateTemplateParser(LateTemplateParserCB *LTP,
898	LateTemplateParserCleanupCB *LTPCleanup,
899	void *P) {
900	LateTemplateParser = LTP;
901	LateTemplateParserCleanup = LTPCleanup;
902	OpaqueParser = P;
903	}
904
905	class DelayedDiagnostics;
906
907	class DelayedDiagnosticsState {
908	sema::DelayedDiagnosticPool *SavedPool;
909	friend class Sema::DelayedDiagnostics;
910	};
911	typedef DelayedDiagnosticsState ParsingDeclState;
912	typedef DelayedDiagnosticsState ProcessingContextState;
913
914	/// A class which encapsulates the logic for delaying diagnostics
915	/// during parsing and other processing.
916	class DelayedDiagnostics {
917	/// The current pool of diagnostics into which delayed
918	/// diagnostics should go.
919	sema::DelayedDiagnosticPool *CurPool;
920
921	public:
922	DelayedDiagnostics() : CurPool(nullptr) {}
923
924	/// Adds a delayed diagnostic.
925	void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
926
927	/// Determines whether diagnostics should be delayed.
928	bool shouldDelayDiagnostics() { return CurPool != nullptr; }
929
930	/// Returns the current delayed-diagnostics pool.
931	sema::DelayedDiagnosticPool getCurrentPool() const* {
932	return CurPool;
933	}
934
935	/// Enter a new scope. Access and deprecation diagnostics will be
936	/// collected in this pool.
937	DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
938	DelayedDiagnosticsState state;
939	state.SavedPool = CurPool;
940	CurPool = &pool;
941	return state;
942	}
943
944	/// Leave a delayed-diagnostic state that was previously pushed.
945	/// Do not emit any of the diagnostics. This is performed as part
946	/// of the bookkeeping of popping a pool "properly".
947	void popWithoutEmitting(DelayedDiagnosticsState state) {
948	CurPool = state.SavedPool;
949	}
950
951	/// Enter a new scope where access and deprecation diagnostics are
952	/// not delayed.
953	DelayedDiagnosticsState pushUndelayed() {
954	DelayedDiagnosticsState state;
955	state.SavedPool = CurPool;
956	CurPool = nullptr;
957	return state;
958	}
959
960	/// Undo a previous pushUndelayed().
961	void popUndelayed(DelayedDiagnosticsState state) {
962	assert(CurPool == nullptr);
963	CurPool = state.SavedPool;
964	}
965	} DelayedDiagnostics;
966
967	/// A RAII object to temporarily push a declaration context.
968	class ContextRAII {
969	private:
970	Sema &S;
971	DeclContext *SavedContext;
972	ProcessingContextState SavedContextState;
973	QualType SavedCXXThisTypeOverride;
974	unsigned SavedFunctionScopesStart;
975	unsigned SavedInventedParameterInfosStart;
976
977	public:
978	ContextRAII(Sema &S, DeclContext ContextToPush, bool* NewThisContext = true)
979	: S(S), SavedContext(S.CurContext),
980	SavedContextState (S.DelayedDiagnostics.pushUndelayed()),
981	SavedCXXThisTypeOverride (S.CXXThisTypeOverride),
982	SavedFunctionScopesStart(S.FunctionScopesStart),
983	SavedInventedParameterInfosStart(S.InventedParameterInfosStart)
984	{
985	assert(ContextToPush && "pushing null context");
986	S.CurContext = ContextToPush;
987	if (NewThisContext)
988	S.CXXThisTypeOverride = QualType ();
989	// Any saved FunctionScopes do not refer to this context.
990	S.FunctionScopesStart = S.FunctionScopes.size();
991	S.InventedParameterInfosStart = S.InventedParameterInfos.size();
992	}
993
994	void pop() {
995	if (!SavedContext) return;
996	S.CurContext = SavedContext;
997	S.DelayedDiagnostics.popUndelayed(SavedContextState);
998	S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
999	S.FunctionScopesStart = SavedFunctionScopesStart;
1000	S.InventedParameterInfosStart = SavedInventedParameterInfosStart;
1001	SavedContext = nullptr;
1002	}
1003
1004	~ContextRAII() {
1005	pop();
1006	}
1007	};
1008
1009	/// Whether the AST is currently being rebuilt to correct immediate
1010	/// invocations. Immediate invocation candidates and references to consteval
1011	/// functions aren't tracked when this is set.
1012	bool RebuildingImmediateInvocation = false;
1013
1014	/// Used to change context to isConstantEvaluated without pushing a heavy
1015	/// ExpressionEvaluationContextRecord object.
1016	bool isConstantEvaluatedOverride;
1017
1018	bool isConstantEvaluated() {
1019	return ExprEvalContexts.back().isConstantEvaluated() \|\|
1020	isConstantEvaluatedOverride;
1021	}
1022
1023	/// RAII object to handle the state changes required to synthesize
1024	/// a function body.
1025	class SynthesizedFunctionScope {
1026	Sema &S;
1027	Sema::ContextRAII SavedContext;
1028	bool PushedCodeSynthesisContext = false;
1029
1030	public:
1031	SynthesizedFunctionScope(Sema &S, DeclContext *DC)
1032	: S(S), SavedContext (S, DC) {
1033	S.PushFunctionScope();
1034	S.PushExpressionEvaluationContext(
1035	Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1036	if (auto *FD = dyn_cast<FunctionDecl>(DC))
1037	FD->setWillHaveBody(true);
1038	else
1039	assert(isa<ObjCMethodDecl>(DC));
1040	}
1041
1042	void addContextNote(SourceLocation UseLoc) {
1043	assert(!PushedCodeSynthesisContext);
1044
1045	Sema::CodeSynthesisContext Ctx;
1046	Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
1047	Ctx.PointOfInstantiation = UseLoc;
1048	Ctx.Entity = cast<Decl>(S.CurContext);
1049	S.pushCodeSynthesisContext(Ctx);
1050
1051	PushedCodeSynthesisContext = true;
1052	}
1053
1054	~SynthesizedFunctionScope() {
1055	if (PushedCodeSynthesisContext)
1056	S.popCodeSynthesisContext();
1057	if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
1058	FD->setWillHaveBody(false);
1059	S.PopExpressionEvaluationContext();
1060	S.PopFunctionScopeInfo();
1061	}
1062	};
1063
1064	/// WeakUndeclaredIdentifiers - Identifiers contained in
1065	/// \#pragma weak before declared. rare. may alias another
1066	/// identifier, declared or undeclared
1067	llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
1068
1069	/// ExtnameUndeclaredIdentifiers - Identifiers contained in
1070	/// \#pragma redefine_extname before declared. Used in Solaris system headers
1071	/// to define functions that occur in multiple standards to call the version
1072	/// in the currently selected standard.
1073	llvm::DenseMap<IdentifierInfo,AsmLabelAttr> ExtnameUndeclaredIdentifiers;
1074
1075
1076	/// Load weak undeclared identifiers from the external source.
1077	void LoadExternalWeakUndeclaredIdentifiers();
1078
1079	/// WeakTopLevelDecl - Translation-unit scoped declarations generated by
1080	/// \#pragma weak during processing of other Decls.
1081	/// I couldn't figure out a clean way to generate these in-line, so
1082	/// we store them here and handle separately -- which is a hack.
1083	/// It would be best to refactor this.
1084	SmallVector<Decl*,`2`> WeakTopLevelDecl;
1085
1086	IdentifierResolver IdResolver;
1087
1088	/// Translation Unit Scope - useful to Objective-C actions that need
1089	/// to lookup file scope declarations in the "ordinary" C decl namespace.
1090	/// For example, user-defined classes, built-in "id" type, etc.
1091	Scope *TUScope;
1092
1093	/// The C++ "std" namespace, where the standard library resides.
1094	LazyDeclPtr StdNamespace;
1095
1096	/// The C++ "std::bad_alloc" class, which is defined by the C++
1097	/// standard library.
1098	LazyDeclPtr StdBadAlloc;
1099
1100	/// The C++ "std::align_val_t" enum class, which is defined by the C++
1101	/// standard library.
1102	LazyDeclPtr StdAlignValT;
1103
1104	/// The C++ "std::experimental" namespace, where the experimental parts
1105	/// of the standard library resides.
1106	NamespaceDecl *StdExperimentalNamespaceCache;
1107
1108	/// The C++ "std::initializer_list" template, which is defined in
1109	/// \<initializer_list>.
1110	ClassTemplateDecl *StdInitializerList;
1111
1112	/// The C++ "std::coroutine_traits" template, which is defined in
1113	/// \<coroutine_traits>
1114	ClassTemplateDecl *StdCoroutineTraitsCache;
1115
1116	/// The C++ "type_info" declaration, which is defined in \<typeinfo>.
1117	RecordDecl *CXXTypeInfoDecl;
1118
1119	/// The MSVC "_GUID" struct, which is defined in MSVC header files.
1120	RecordDecl *MSVCGuidDecl;
1121
1122	/// Caches identifiers/selectors for NSFoundation APIs.
1123	std::unique_ptr<NSAPI> NSAPIObj;
1124
1125	/// The declaration of the Objective-C NSNumber class.
1126	ObjCInterfaceDecl *NSNumberDecl;
1127
1128	/// The declaration of the Objective-C NSValue class.
1129	ObjCInterfaceDecl *NSValueDecl;
1130
1131	/// Pointer to NSNumber type (NSNumber ).*
1132	QualType NSNumberPointer;
1133
1134	/// Pointer to NSValue type (NSValue ).*
1135	QualType NSValuePointer;
1136
1137	/// The Objective-C NSNumber methods used to create NSNumber literals.
1138	ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
1139
1140	/// The declaration of the Objective-C NSString class.
1141	ObjCInterfaceDecl *NSStringDecl;
1142
1143	/// Pointer to NSString type (NSString ).*
1144	QualType NSStringPointer;
1145
1146	/// The declaration of the stringWithUTF8String: method.
1147	ObjCMethodDecl *StringWithUTF8StringMethod;
1148
1149	/// The declaration of the valueWithBytes:objCType: method.
1150	ObjCMethodDecl *ValueWithBytesObjCTypeMethod;
1151
1152	/// The declaration of the Objective-C NSArray class.
1153	ObjCInterfaceDecl *NSArrayDecl;
1154
1155	/// The declaration of the arrayWithObjects:count: method.
1156	ObjCMethodDecl *ArrayWithObjectsMethod;
1157
1158	/// The declaration of the Objective-C NSDictionary class.
1159	ObjCInterfaceDecl *NSDictionaryDecl;
1160
1161	/// The declaration of the dictionaryWithObjects:forKeys:count: method.
1162	ObjCMethodDecl *DictionaryWithObjectsMethod;
1163
1164	/// id<NSCopying> type.
1165	QualType QIDNSCopying;
1166
1167	/// will hold 'respondsToSelector:'
1168	Selector RespondsToSelectorSel;
1169
1170	/// A flag to remember whether the implicit forms of operator new and delete
1171	/// have been declared.
1172	bool GlobalNewDeleteDeclared;
1173
1174	/// Describes how the expressions currently being parsed are
1175	/// evaluated at run-time, if at all.
1176	enum class ExpressionEvaluationContext {
1177	/// The current expression and its subexpressions occur within an
1178	/// unevaluated operand (C++11 [expr]p7), such as the subexpression of
1179	/// \c sizeof, where the type of the expression may be significant but
1180	/// no code will be generated to evaluate the value of the expression at
1181	/// run time.
1182	Unevaluated,
1183
1184	/// The current expression occurs within a braced-init-list within
1185	/// an unevaluated operand. This is mostly like a regular unevaluated
1186	/// context, except that we still instantiate constexpr functions that are
1187	/// referenced here so that we can perform narrowing checks correctly.
1188	UnevaluatedList,
1189
1190	/// The current expression occurs within a discarded statement.
1191	/// This behaves largely similarly to an unevaluated operand in preventing
1192	/// definitions from being required, but not in other ways.
1193	DiscardedStatement,
1194
1195	/// The current expression occurs within an unevaluated
1196	/// operand that unconditionally permits abstract references to
1197	/// fields, such as a SIZE operator in MS-style inline assembly.
1198	UnevaluatedAbstract,
1199
1200	/// The current context is "potentially evaluated" in C++11 terms,
1201	/// but the expression is evaluated at compile-time (like the values of
1202	/// cases in a switch statement).
1203	ConstantEvaluated,
1204
1205	/// The current expression is potentially evaluated at run time,
1206	/// which means that code may be generated to evaluate the value of the
1207	/// expression at run time.
1208	PotentiallyEvaluated,
1209
1210	/// The current expression is potentially evaluated, but any
1211	/// declarations referenced inside that expression are only used if
1212	/// in fact the current expression is used.
1213	///
1214	/// This value is used when parsing default function arguments, for which
1215	/// we would like to provide diagnostics (e.g., passing non-POD arguments
1216	/// through varargs) but do not want to mark declarations as "referenced"
1217	/// until the default argument is used.
1218	PotentiallyEvaluatedIfUsed
1219	};
1220
1221	using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, `1`>;
1222
1223	/// Data structure used to record current or nested
1224	/// expression evaluation contexts.
1225	struct ExpressionEvaluationContextRecord {
1226	/// The expression evaluation context.
1227	ExpressionEvaluationContext Context;
1228
1229	/// Whether the enclosing context needed a cleanup.
1230	CleanupInfo ParentCleanup;
1231
1232	/// The number of active cleanup objects when we entered
1233	/// this expression evaluation context.
1234	unsigned NumCleanupObjects;
1235
1236	/// The number of typos encountered during this expression evaluation
1237	/// context (i.e. the number of TypoExprs created).
1238	unsigned NumTypos;
1239
1240	MaybeODRUseExprSet SavedMaybeODRUseExprs;
1241
1242	/// The lambdas that are present within this context, if it
1243	/// is indeed an unevaluated context.
1244	SmallVector<LambdaExpr *, `2`> Lambdas;
1245
1246	/// The declaration that provides context for lambda expressions
1247	/// and block literals if the normal declaration context does not
1248	/// suffice, e.g., in a default function argument.
1249	Decl *ManglingContextDecl;
1250
1251	/// If we are processing a decltype type, a set of call expressions
1252	/// for which we have deferred checking the completeness of the return type.
1253	SmallVector<CallExpr *, `8`> DelayedDecltypeCalls;
1254
1255	/// If we are processing a decltype type, a set of temporary binding
1256	/// expressions for which we have deferred checking the destructor.
1257	SmallVector<CXXBindTemporaryExpr *, `8`> DelayedDecltypeBinds;
1258
1259	llvm::SmallPtrSet<const Expr *, `8`> PossibleDerefs;
1260
1261	/// Expressions appearing as the LHS of a volatile assignment in this
1262	/// context. We produce a warning for these when popping the context if
1263	/// they are not discarded-value expressions nor unevaluated operands.
1264	SmallVector<Expr*, `2`> VolatileAssignmentLHSs;
1265
1266	/// Set of candidates for starting an immediate invocation.
1267	llvm::SmallVector<ImmediateInvocationCandidate, `4`> ImmediateInvocationCandidates;
1268
1269	/// Set of DeclRefExprs referencing a consteval function when used in a
1270	/// context not already known to be immediately invoked.
1271	llvm::SmallPtrSet<DeclRefExpr *, `4`> ReferenceToConsteval;
1272
1273	/// \brief Describes whether we are in an expression constext which we have
1274	/// to handle differently.
1275	enum ExpressionKind {
1276	EK_Decltype, EK_TemplateArgument, EK_Other
1277	} ExprContext;
1278
1279	ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
1280	unsigned NumCleanupObjects,
1281	CleanupInfo ParentCleanup,
1282	Decl *ManglingContextDecl,
1283	ExpressionKind ExprContext)
1284	: Context(Context), ParentCleanup (ParentCleanup),
1285	NumCleanupObjects(NumCleanupObjects), NumTypos(`0`),
1286	ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {}
1287
1288	bool isUnevaluated() const {
1289	return Context == ExpressionEvaluationContext::Unevaluated \|\|
1290	Context == ExpressionEvaluationContext::UnevaluatedAbstract \|\|
1291	Context == ExpressionEvaluationContext::UnevaluatedList;
1292	}
1293	bool isConstantEvaluated() const {
1294	return Context == ExpressionEvaluationContext::ConstantEvaluated;
1295	}
1296	};
1297
1298	/// A stack of expression evaluation contexts.
1299	SmallVector<ExpressionEvaluationContextRecord, `8`> ExprEvalContexts;
1300
1301	/// Emit a warning for all pending noderef expressions that we recorded.
1302	void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
1303
1304	/// Compute the mangling number context for a lambda expression or
1305	/// block literal. Also return the extra mangling decl if any.
1306	///
1307	/// \param DC - The DeclContext containing the lambda expression or
1308	/// block literal.
1309	std::tuple<MangleNumberingContext , Decl >
1310	getCurrentMangleNumberContext(const DeclContext *DC);
1311
1312
1313	/// SpecialMemberOverloadResult - The overloading result for a special member
1314	/// function.
1315	///
1316	/// This is basically a wrapper around PointerIntPair. The lowest bits of the
1317	/// integer are used to determine whether overload resolution succeeded.
1318	class SpecialMemberOverloadResult {
1319	public:
1320	enum Kind {
1321	NoMemberOrDeleted,
1322	Ambiguous,
1323	Success
1324	};
1325
1326	private:
1327	llvm::PointerIntPair<CXXMethodDecl*, `2`> Pair;
1328
1329	public:
1330	SpecialMemberOverloadResult() : Pair () {}
1331	SpecialMemberOverloadResult(CXXMethodDecl *MD)
1332	: Pair (MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1333
1334	CXXMethodDecl getMethod() const* { return Pair.getPointer(); }
1335	void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1336
1337	Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1338	void setKind(Kind K) { Pair.setInt(K); }
1339	};
1340
1341	class SpecialMemberOverloadResultEntry
1342	: public llvm::FastFoldingSetNode,
1343	public SpecialMemberOverloadResult {
1344	public:
1345	SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1346	: FastFoldingSetNode (ID)
1347	{}
1348	};
1349
1350	/// A cache of special member function overload resolution results
1351	/// for C++ records.
1352	llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1353
1354	/// A cache of the flags available in enumerations with the flag_bits
1355	/// attribute.
1356	mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1357
1358	/// The kind of translation unit we are processing.
1359	///
1360	/// When we're processing a complete translation unit, Sema will perform
1361	/// end-of-translation-unit semantic tasks (such as creating
1362	/// initializers for tentative definitions in C) once parsing has
1363	/// completed. Modules and precompiled headers perform different kinds of
1364	/// checks.
1365	TranslationUnitKind TUKind;
1366
1367	llvm::BumpPtrAllocator BumpAlloc;
1368
1369	/// The number of SFINAE diagnostics that have been trapped.
1370	unsigned NumSFINAEErrors;
1371
1372	typedef llvm::DenseMap<ParmVarDecl , llvm::TinyPtrVector<ParmVarDecl >>
1373	UnparsedDefaultArgInstantiationsMap;
1374
1375	/// A mapping from parameters with unparsed default arguments to the
1376	/// set of instantiations of each parameter.
1377	///
1378	/// This mapping is a temporary data structure used when parsing
1379	/// nested class templates or nested classes of class templates,
1380	/// where we might end up instantiating an inner class before the
1381	/// default arguments of its methods have been parsed.
1382	UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
1383
1384	// Contains the locations of the beginning of unparsed default
1385	// argument locations.
1386	llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1387
1388	/// UndefinedInternals - all the used, undefined objects which require a
1389	/// definition in this translation unit.
1390	llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1391
1392	/// Determine if VD, which must be a variable or function, is an external
1393	/// symbol that nonetheless can't be referenced from outside this translation
1394	/// unit because its type has no linkage and it's not extern "C".
1395	bool isExternalWithNoLinkageType(ValueDecl *VD);
1396
1397	/// Obtain a sorted list of functions that are undefined but ODR-used.
1398	void getUndefinedButUsed(
1399	SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1400
1401	/// Retrieves list of suspicious delete-expressions that will be checked at
1402	/// the end of translation unit.
1403	const llvm::MapVector<FieldDecl *, DeleteLocs> &
1404	getMismatchingDeleteExpressions() const;
1405
1406	typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
1407	typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
1408
1409	/// Method Pool - allows efficient lookup when typechecking messages to "id".
1410	/// We need to maintain a list, since selectors can have differing signatures
1411	/// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1412	/// of selectors are "overloaded").
1413	/// At the head of the list it is recorded whether there were 0, 1, or >= 2
1414	/// methods inside categories with a particular selector.
1415	GlobalMethodPool MethodPool;
1416
1417	/// Method selectors used in a \@selector expression. Used for implementation
1418	/// of -Wselector.
1419	llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1420
1421	/// List of SourceLocations where 'self' is implicitly retained inside a
1422	/// block.
1423	llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, `1`>
1424	ImplicitlyRetainedSelfLocs;
1425
1426	/// Kinds of C++ special members.
1427	enum CXXSpecialMember {
1428	CXXDefaultConstructor,
1429	CXXCopyConstructor,
1430	CXXMoveConstructor,
1431	CXXCopyAssignment,
1432	CXXMoveAssignment,
1433	CXXDestructor,
1434	CXXInvalid
1435	};
1436
1437	typedef llvm::PointerIntPair<CXXRecordDecl *, `3`, CXXSpecialMember>
1438	SpecialMemberDecl;
1439
1440	/// The C++ special members which we are currently in the process of
1441	/// declaring. If this process recursively triggers the declaration of the
1442	/// same special member, we should act as if it is not yet declared.
1443	llvm::SmallPtrSet<SpecialMemberDecl, `4`> SpecialMembersBeingDeclared;
1444
1445	/// Kinds of defaulted comparison operator functions.
1446	enum class DefaultedComparisonKind : unsigned char {
1447	/// This is not a defaultable comparison operator.
1448	None,
1449	/// This is an operator== that should be implemented as a series of
1450	/// subobject comparisons.
1451	Equal,
1452	/// This is an operator<=> that should be implemented as a series of
1453	/// subobject comparisons.
1454	ThreeWay,
1455	/// This is an operator!= that should be implemented as a rewrite in terms
1456	/// of a == comparison.
1457	NotEqual,
1458	/// This is an <, <=, >, or >= that should be implemented as a rewrite in
1459	/// terms of a <=> comparison.
1460	Relational,
1461	};
1462
1463	/// The function definitions which were renamed as part of typo-correction
1464	/// to match their respective declarations. We want to keep track of them
1465	/// to ensure that we don't emit a "redefinition" error if we encounter a
1466	/// correctly named definition after the renamed definition.
1467	llvm::SmallPtrSet<const NamedDecl *, `4`> TypoCorrectedFunctionDefinitions;
1468
1469	/// Stack of types that correspond to the parameter entities that are
1470	/// currently being copy-initialized. Can be empty.
1471	llvm::SmallVector<QualType, `4`> CurrentParameterCopyTypes;
1472
1473	void ReadMethodPool(Selector Sel);
1474	void updateOutOfDateSelector(Selector Sel);
1475
1476	/// Private Helper predicate to check for 'self'.
1477	bool isSelfExpr(Expr *RExpr);
1478	bool isSelfExpr(Expr RExpr, const* ObjCMethodDecl *Method);
1479
1480	/// Cause the active diagnostic on the DiagosticsEngine to be
1481	/// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1482	/// should not be used elsewhere.
1483	void EmitCurrentDiagnostic(unsigned DiagID);
1484
1485	/// Records and restores the CurFPFeatures state on entry/exit of compound
1486	/// statements.
1487	class FPFeaturesStateRAII {
1488	public:
1489	FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState (S.CurFPFeatures) {
1490	OldOverrides = S.FpPragmaStack.CurrentValue;
1491	}
1492	~FPFeaturesStateRAII() {
1493	S.CurFPFeatures = OldFPFeaturesState;
1494	S.FpPragmaStack.CurrentValue = OldOverrides;
1495	}
1496	FPOptionsOverride getOverrides() { return OldOverrides; }
1497
1498	private:
1499	Sema& S;
1500	FPOptions OldFPFeaturesState;
1501	FPOptionsOverride OldOverrides;
1502	};
1503
1504	void addImplicitTypedef(StringRef Name, QualType T);
1505
1506	bool WarnedStackExhausted = false;
1507
1508	public:
1509	Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1510	TranslationUnitKind TUKind = TU_Complete,
1511	CodeCompleteConsumer CompletionConsumer = nullptr*);
1512	~Sema();
1513
1514	/// Perform initialization that occurs after the parser has been
1515	/// initialized but before it parses anything.
1516	void Initialize();
1517
1518	const LangOptions &getLangOpts() const { return LangOpts; }
1519	OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1520	FPOptions &getCurFPFeatures() { return CurFPFeatures; }
1521
1522	DiagnosticsEngine &getDiagnostics() const { return Diags; }
1523	SourceManager &getSourceManager() const { return SourceMgr; }
1524	Preprocessor &getPreprocessor() const { return PP; }
1525	ASTContext &getASTContext() const { return Context; }
1526	ASTConsumer &getASTConsumer() const { return Consumer; }
1527	ASTMutationListener getASTMutationListener() const*;
1528	ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1529
1530	///Registers an external source. If an external source already exists,
1531	/// creates a multiplex external source and appends to it.
1532	///
1533	///\param[in] E - A non-null external sema source.
1534	///
1535	void addExternalSource(ExternalSemaSource *E);
1536
1537	void PrintStats() const;
1538
1539	/// Warn that the stack is nearly exhausted.
1540	void warnStackExhausted(SourceLocation Loc);
1541
1542	/// Run some code with "sufficient" stack space. (Currently, at least 256K is
1543	/// guaranteed). Produces a warning if we're low on stack space and allocates
1544	/// more in that case. Use this in code that may recurse deeply (for example,
1545	/// in template instantiation) to avoid stack overflow.
1546	void runWithSufficientStackSpace(SourceLocation Loc,
1547	llvm::function_ref<void()> Fn);
1548
1549	/// Helper class that creates diagnostics with optional
1550	/// template instantiation stacks.
1551	///
1552	/// This class provides a wrapper around the basic DiagnosticBuilder
1553	/// class that emits diagnostics. ImmediateDiagBuilder is
1554	/// responsible for emitting the diagnostic (as DiagnosticBuilder
1555	/// does) and, if the diagnostic comes from inside a template
1556	/// instantiation, printing the template instantiation stack as
1557	/// well.
1558	class ImmediateDiagBuilder : public DiagnosticBuilder {
1559	Sema &SemaRef;
1560	unsigned DiagID;
1561
1562	public:
1563	ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1564	: DiagnosticBuilder (DB), SemaRef(SemaRef), DiagID(DiagID) {}
1565	ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID)
1566	: DiagnosticBuilder (DB), SemaRef(SemaRef), DiagID(DiagID) {}
1567
1568	// This is a cunning lie. DiagnosticBuilder actually performs move
1569	// construction in its copy constructor (but due to varied uses, it's not
1570	// possible to conveniently express this as actual move construction). So
1571	// the default copy ctor here is fine, because the base class disables the
1572	// source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op
1573	// in that case anwyay.
1574	ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default;
1575
1576	~ImmediateDiagBuilder() {
1577	// If we aren't active, there is nothing to do.
1578	if (!isActive()) return;
1579
1580	// Otherwise, we need to emit the diagnostic. First clear the diagnostic
1581	// builder itself so it won't emit the diagnostic in its own destructor.
1582	//
1583	// This seems wasteful, in that as written the DiagnosticBuilder dtor will
1584	// do its own needless checks to see if the diagnostic needs to be
1585	// emitted. However, because we take care to ensure that the builder
1586	// objects never escape, a sufficiently smart compiler will be able to
1587	// eliminate that code.
1588	Clear();
1589
1590	// Dispatch to Sema to emit the diagnostic.
1591	SemaRef.EmitCurrentDiagnostic(DiagID);
1592	}
1593
1594	/// Teach operator<< to produce an object of the correct type.
1595	template <typename T>
1596	friend const ImmediateDiagBuilder &
1597	operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1598	const DiagnosticBuilder &BaseDiag = Diag;
1599	BaseDiag << Value;
1600	return Diag;
1601	}
1602
1603	// It is necessary to limit this to rvalue reference to avoid calling this
1604	// function with a bitfield lvalue argument since non-const reference to
1605	// bitfield is not allowed.
1606	template <typename T, typename = typename std::enable_if<
1607	!std::is_lvalue_reference<T>::value>::type>
1608	const ImmediateDiagBuilder &operator<<(T &&V) const {
1609	const DiagnosticBuilder &BaseDiag = *this;
1610	BaseDiag << std::move(V);
1611	return *this;
1612	}
1613	};
1614
1615	/// A generic diagnostic builder for errors which may or may not be deferred.
1616	///
1617	/// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)
1618	/// which are not allowed to appear inside __device__ functions and are
1619	/// allowed to appear in __host__ __device__ functions only if the host+device
1620	/// function is never codegen'ed.
1621	///
1622	/// To handle this, we use the notion of "deferred diagnostics", where we
1623	/// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.
1624	///
1625	/// This class lets you emit either a regular diagnostic, a deferred
1626	/// diagnostic, or no diagnostic at all, according to an argument you pass to
1627	/// its constructor, thus simplifying the process of creating these "maybe
1628	/// deferred" diagnostics.
1629	class SemaDiagnosticBuilder {
1630	public:
1631	enum Kind {
1632	/// Emit no diagnostics.
1633	K_Nop,
1634	/// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
1635	K_Immediate,
1636	/// Emit the diagnostic immediately, and, if it's a warning or error, also
1637	/// emit a call stack showing how this function can be reached by an a
1638	/// priori known-emitted function.
1639	K_ImmediateWithCallStack,
1640	/// Create a deferred diagnostic, which is emitted only if the function
1641	/// it's attached to is codegen'ed. Also emit a call stack as with
1642	/// K_ImmediateWithCallStack.
1643	K_Deferred
1644	};
1645
1646	SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
1647	FunctionDecl *Fn, Sema &S);
1648	SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D);
1649	SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default;
1650	~SemaDiagnosticBuilder();
1651
1652	bool isImmediate() const { return ImmediateDiag.hasValue(); }
1653
1654	/// Convertible to bool: True if we immediately emitted an error, false if
1655	/// we didn't emit an error or we created a deferred error.
1656	///
1657	/// Example usage:
1658	///
1659	/// if (SemaDiagnosticBuilder(...) << foo << bar)
1660	/// return ExprError();
1661	///
1662	/// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably
1663	/// want to use these instead of creating a SemaDiagnosticBuilder yourself.
1664	operator bool() const { return isImmediate(); }
1665
1666	template <typename T>
1667	friend const SemaDiagnosticBuilder &
1668	operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1669	if (Diag.ImmediateDiag.hasValue())
1670	*Diag.ImmediateDiag << Value;
1671	else if (Diag.PartialDiagId.hasValue())
1672	Diag.S.DeviceDeferredDiags [Diag.Fn][*Diag.PartialDiagId].second
1673	<< Value;
1674	return Diag;
1675	}
1676
1677	// It is necessary to limit this to rvalue reference to avoid calling this
1678	// function with a bitfield lvalue argument since non-const reference to
1679	// bitfield is not allowed.
1680	template <typename T, typename = typename std::enable_if<
1681	!std::is_lvalue_reference<T>::value>::type>
1682	const SemaDiagnosticBuilder &operator<<(T &&V) const {
1683	if (ImmediateDiag.hasValue())
1684	*ImmediateDiag << std::move(V);
1685	else if (PartialDiagId.hasValue())
1686	S.DeviceDeferredDiags [Fn][*PartialDiagId].second << std::move(V);
1687	return *this;
1688	}
1689
1690	friend const SemaDiagnosticBuilder &
1691	operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) {
1692	if (Diag.ImmediateDiag.hasValue())
1693	PD.Emit(*Diag.ImmediateDiag);
1694	else if (Diag.PartialDiagId.hasValue())
1695	Diag.S.DeviceDeferredDiags [Diag.Fn][*Diag.PartialDiagId].second = PD;
1696	return Diag;
1697	}
1698
1699	void AddFixItHint(const FixItHint &Hint) const {
1700	if (ImmediateDiag.hasValue())
1701	ImmediateDiag ->AddFixItHint(Hint);
1702	else if (PartialDiagId.hasValue())
1703	S.DeviceDeferredDiags [Fn][*PartialDiagId].second.AddFixItHint(Hint);
1704	}
1705
1706	friend ExprResult ExprError(const SemaDiagnosticBuilder &) {
1707	return ExprError();
1708	}
1709	friend StmtResult StmtError(const SemaDiagnosticBuilder &) {
1710	return StmtError();
1711	}
1712	operator ExprResult() const { return ExprError(); }
1713	operator StmtResult() const { return StmtError(); }
1714	operator TypeResult() const { return TypeError(); }
1715	operator DeclResult() const { return DeclResult (true); }
1716	operator MemInitResult() const { return MemInitResult (true); }
1717
1718	private:
1719	Sema &S;
1720	SourceLocation Loc;
1721	unsigned DiagID;
1722	FunctionDecl *Fn;
1723	bool ShowCallStack;
1724
1725	// Invariant: At most one of these Optionals has a value.
1726	// FIXME: Switch these to a Variant once that exists.
1727	llvm::Optional<ImmediateDiagBuilder> ImmediateDiag;
1728	llvm::Optional<unsigned> PartialDiagId;
1729	};
1730
1731	/// Is the last error level diagnostic immediate. This is used to determined
1732	/// whether the next info diagnostic should be immediate.
1733	bool IsLastErrorImmediate = true;
1734
1735	/// Emit a diagnostic.
1736	SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID,
1737	bool DeferHint = false);
1738
1739	/// Emit a partial diagnostic.
1740	SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD,
1741	bool DeferHint = false);
1742
1743	/// Build a partial diagnostic.
1744	PartialDiagnostic PDiag(unsigned DiagID = `0`); // in SemaInternal.h
1745
1746	/// Whether uncompilable error has occurred. This includes error happens
1747	/// in deferred diagnostics.
1748	bool hasUncompilableErrorOccurred() const;
1749
1750	bool findMacroSpelling(SourceLocation &loc, StringRef name);
1751
1752	/// Get a string to suggest for zero-initialization of a type.
1753	std::string
1754	getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1755	std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1756
1757	/// Calls \c Lexer::getLocForEndOfToken()
1758	SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = `0`);
1759
1760	/// Retrieve the module loader associated with the preprocessor.
1761	ModuleLoader &getModuleLoader() const;
1762
1763	/// Invent a new identifier for parameters of abbreviated templates.
1764	IdentifierInfo *
1765	InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName,
1766	unsigned Index);
1767
1768	void emitAndClearUnusedLocalTypedefWarnings();
1769
1770	private:
1771	/// Function or variable declarations to be checked for whether the deferred
1772	/// diagnostics should be emitted.
1773	SmallVector<Decl *, `4`> DeclsToCheckForDeferredDiags;
1774
1775	public:
1776	// Emit all deferred diagnostics.
1777	void emitDeferredDiags();
1778
1779	enum TUFragmentKind {
1780	/// The global module fragment, between 'module;' and a module-declaration.
1781	Global,
1782	/// A normal translation unit fragment. For a non-module unit, this is the
1783	/// entire translation unit. Otherwise, it runs from the module-declaration
1784	/// to the private-module-fragment (if any) or the end of the TU (if not).
1785	Normal,
1786	/// The private module fragment, between 'module :private;' and the end of
1787	/// the translation unit.
1788	Private
1789	};
1790
1791	void ActOnStartOfTranslationUnit();
1792	void ActOnEndOfTranslationUnit();
1793	void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind);
1794
1795	void CheckDelegatingCtorCycles();
1796
1797	Scope getScopeForContext(DeclContext Ctx);
1798
1799	void PushFunctionScope();
1800	void PushBlockScope(Scope BlockScope, BlockDecl Block);
1801	sema::LambdaScopeInfo *PushLambdaScope();
1802
1803	/// This is used to inform Sema what the current TemplateParameterDepth
1804	/// is during Parsing. Currently it is used to pass on the depth
1805	/// when parsing generic lambda 'auto' parameters.
1806	void RecordParsingTemplateParameterDepth(unsigned Depth);
1807
1808	void PushCapturedRegionScope(Scope RegionScope, CapturedDecl CD,
1809	RecordDecl *RD, CapturedRegionKind K,
1810	unsigned OpenMPCaptureLevel = `0`);
1811
1812	/// Custom deleter to allow FunctionScopeInfos to be kept alive for a short
1813	/// time after they've been popped.
1814	class PoppedFunctionScopeDeleter {
1815	Sema *Self;
1816
1817	public:
1818	explicit PoppedFunctionScopeDeleter(Sema *Self) : Self(Self) {}
1819	void operator()(sema::FunctionScopeInfo Scope) const*;
1820	};
1821
1822	using PoppedFunctionScopePtr =
1823	std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>;
1824
1825	PoppedFunctionScopePtr
1826	PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy WP = nullptr*,
1827	const Decl D = nullptr*,
1828	QualType BlockType = QualType ());
1829
1830	sema::FunctionScopeInfo getCurFunction() const* {
1831	return FunctionScopes.empty() ? nullptr : FunctionScopes.back();
1832	}
1833
1834	sema::FunctionScopeInfo getEnclosingFunction() const*;
1835
1836	void setFunctionHasBranchIntoScope();
1837	void setFunctionHasBranchProtectedScope();
1838	void setFunctionHasIndirectGoto();
1839
1840	void PushCompoundScope(bool IsStmtExpr);
1841	void PopCompoundScope();
1842
1843	sema::CompoundScopeInfo &getCurCompoundScope() const;
1844
1845	bool hasAnyUnrecoverableErrorsInThisFunction() const;
1846
1847	/// Retrieve the current block, if any.
1848	sema::BlockScopeInfo *getCurBlock();
1849
1850	/// Get the innermost lambda enclosing the current location, if any. This
1851	/// looks through intervening non-lambda scopes such as local functions and
1852	/// blocks.
1853	sema::LambdaScopeInfo getEnclosingLambda() const*;
1854
1855	/// Retrieve the current lambda scope info, if any.
1856	/// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1857	/// lambda scope info ignoring all inner capturing scopes that are not
1858	/// lambda scopes.
1859	sema::LambdaScopeInfo *
1860	getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1861
1862	/// Retrieve the current generic lambda info, if any.
1863	sema::LambdaScopeInfo *getCurGenericLambda();
1864
1865	/// Retrieve the current captured region, if any.
1866	sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1867
1868	/// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1869	SmallVectorImpl<Decl > &WeakTopLevelDecls() { return* WeakTopLevelDecl; }
1870
1871	/// Called before parsing a function declarator belonging to a function
1872	/// declaration.
1873	void ActOnStartFunctionDeclarationDeclarator(Declarator &D,
1874	unsigned TemplateParameterDepth);
1875
1876	/// Called after parsing a function declarator belonging to a function
1877	/// declaration.
1878	void ActOnFinishFunctionDeclarationDeclarator(Declarator &D);
1879
1880	void ActOnComment(SourceRange Comment);
1881
1882	//===--------------------------------------------------------------------===//
1883	// Type Analysis / Processing: SemaType.cpp.
1884	//
1885
1886	QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1887	const DeclSpec DS = nullptr*);
1888	QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1889	const DeclSpec DS = nullptr*);
1890	QualType BuildPointerType(QualType T,
1891	SourceLocation Loc, DeclarationName Entity);
1892	QualType BuildReferenceType(QualType T, bool LValueRef,
1893	SourceLocation Loc, DeclarationName Entity);
1894	QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1895	Expr ArraySize, unsigned* Quals,
1896	SourceRange Brackets, DeclarationName Entity);
1897	QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc);
1898	QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1899	SourceLocation AttrLoc);
1900	QualType BuildMatrixType(QualType T, Expr NumRows, Expr NumColumns,
1901	SourceLocation AttrLoc);
1902
1903	QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
1904	SourceLocation AttrLoc);
1905
1906	/// Same as above, but constructs the AddressSpace index if not provided.
1907	QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1908	SourceLocation AttrLoc);
1909
1910	bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc);
1911
1912	bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1913
1914	/// Build a function type.
1915	///
1916	/// This routine checks the function type according to C++ rules and
1917	/// under the assumption that the result type and parameter types have
1918	/// just been instantiated from a template. It therefore duplicates
1919	/// some of the behavior of GetTypeForDeclarator, but in a much
1920	/// simpler form that is only suitable for this narrow use case.
1921	///
1922	/// \param T The return type of the function.
1923	///
1924	/// \param ParamTypes The parameter types of the function. This array
1925	/// will be modified to account for adjustments to the types of the
1926	/// function parameters.
1927	///
1928	/// \param Loc The location of the entity whose type involves this
1929	/// function type or, if there is no such entity, the location of the
1930	/// type that will have function type.
1931	///
1932	/// \param Entity The name of the entity that involves the function
1933	/// type, if known.
1934	///
1935	/// \param EPI Extra information about the function type. Usually this will
1936	/// be taken from an existing function with the same prototype.
1937	///
1938	/// \returns A suitable function type, if there are no errors. The
1939	/// unqualified type will always be a FunctionProtoType.
1940	/// Otherwise, returns a NULL type.
1941	QualType BuildFunctionType(QualType T,
1942	MutableArrayRef<QualType> ParamTypes,
1943	SourceLocation Loc, DeclarationName Entity,
1944	const FunctionProtoType::ExtProtoInfo &EPI);
1945
1946	QualType BuildMemberPointerType(QualType T, QualType Class,
1947	SourceLocation Loc,
1948	DeclarationName Entity);
1949	QualType BuildBlockPointerType(QualType T,
1950	SourceLocation Loc, DeclarationName Entity);
1951	QualType BuildParenType(QualType T);
1952	QualType BuildAtomicType(QualType T, SourceLocation Loc);
1953	QualType BuildReadPipeType(QualType T,
1954	SourceLocation Loc);
1955	QualType BuildWritePipeType(QualType T,
1956	SourceLocation Loc);
1957	QualType BuildExtIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc);
1958
1959	TypeSourceInfo GetTypeForDeclarator(Declarator &D, Scope S);
1960	TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
1961
1962	/// Package the given type and TSI into a ParsedType.
1963	ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
1964	DeclarationNameInfo GetNameForDeclarator(Declarator &D);
1965	DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
1966	static QualType GetTypeFromParser(ParsedType Ty,
1967	TypeSourceInfo TInfo = nullptr**);
1968	CanThrowResult canThrow(const Stmt *E);
1969	/// Determine whether the callee of a particular function call can throw.
1970	/// E, D and Loc are all optional.
1971	static CanThrowResult canCalleeThrow(Sema &S, const Expr E, const* Decl *D,
1972	SourceLocation Loc = SourceLocation ());
1973	const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
1974	const FunctionProtoType *FPT);
1975	void UpdateExceptionSpec(FunctionDecl *FD,
1976	const FunctionProtoType::ExceptionSpecInfo &ESI);
1977	bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range);
1978	bool CheckDistantExceptionSpec(QualType T);
1979	bool CheckEquivalentExceptionSpec(FunctionDecl Old, FunctionDecl New);
1980	bool CheckEquivalentExceptionSpec(
1981	const FunctionProtoType *Old, SourceLocation OldLoc,
1982	const FunctionProtoType *New, SourceLocation NewLoc);
1983	bool CheckEquivalentExceptionSpec(
1984	const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
1985	const FunctionProtoType *Old, SourceLocation OldLoc,
1986	const FunctionProtoType *New, SourceLocation NewLoc);
1987	bool handlerCanCatch(QualType HandlerType, QualType ExceptionType);
1988	bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
1989	const PartialDiagnostic &NestedDiagID,
1990	const PartialDiagnostic &NoteID,
1991	const PartialDiagnostic &NoThrowDiagID,
1992	const FunctionProtoType *Superset,
1993	SourceLocation SuperLoc,
1994	const FunctionProtoType *Subset,
1995	SourceLocation SubLoc);
1996	bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID,
1997	const PartialDiagnostic &NoteID,
1998	const FunctionProtoType *Target,
1999	SourceLocation TargetLoc,
2000	const FunctionProtoType *Source,
2001	SourceLocation SourceLoc);
2002
2003	TypeResult ActOnTypeName(Scope *S, Declarator &D);
2004
2005	/// The parser has parsed the context-sensitive type 'instancetype'
2006	/// in an Objective-C message declaration. Return the appropriate type.
2007	ParsedType ActOnObjCInstanceType(SourceLocation Loc);
2008
2009	/// Abstract class used to diagnose incomplete types.
2010	struct TypeDiagnoser {
2011	TypeDiagnoser() {}
2012
2013	virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = `0`;
2014	virtual ~TypeDiagnoser() {}
2015	};
2016
2017	static int getPrintable(int I) { return I; }
2018	static unsigned getPrintable(unsigned I) { return I; }
2019	static bool getPrintable(bool B) { return B; }
2020	static const char * getPrintable(const char S) { return* S; }
2021	static StringRef getPrintable(StringRef S) { return S; }
2022	static const std::string &getPrintable(const std::string &S) { return S; }
2023	static const IdentifierInfo getPrintable(const* IdentifierInfo *II) {
2024	return II;
2025	}
2026	static DeclarationName getPrintable(DeclarationName N) { return N; }
2027	static QualType getPrintable(QualType T) { return T; }
2028	static SourceRange getPrintable(SourceRange R) { return R; }
2029	static SourceRange getPrintable(SourceLocation L) { return L; }
2030	static SourceRange getPrintable(const Expr E) { return* E->getSourceRange(); }
2031	static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
2032
2033	template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser {
2034	protected:
2035	unsigned DiagID;
2036	std::tuple<const Ts &...> Args;
2037
2038	template <std::size_t... Is>
2039	void emit(const SemaDiagnosticBuilder &DB,
2040	std::index_sequence<Is...>) const {
2041	// Apply all tuple elements to the builder in order.
2042	bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...};
2043	(void)Dummy;
2044	}
2045
2046	public:
2047	BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
2048	: TypeDiagnoser(), DiagID(DiagID), Args(Args...) {
2049	assert(DiagID != `0` && "no diagnostic for type diagnoser");
2050	}
2051
2052	void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
2053	const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
2054	emit(DB, std::index_sequence_for<Ts...>());
2055	DB << T;
2056	}
2057	};
2058
2059	/// Do a check to make sure \p Name looks like a legal argument for the
2060	/// swift_name attribute applied to decl \p D. Raise a diagnostic if the name
2061	/// is invalid for the given declaration.
2062	///
2063	/// \p AL is used to provide caret diagnostics in case of a malformed name.
2064	///
2065	/// \returns true if the name is a valid swift name for \p D, false otherwise.
2066	bool DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc,
2067	const ParsedAttr &AL, bool IsAsync);
2068
2069	/// A derivative of BoundTypeDiagnoser for which the diagnostic's type
2070	/// parameter is preceded by a 0/1 enum that is 1 if the type is sizeless.
2071	/// For example, a diagnostic with no other parameters would generally have
2072	/// the form "...%select{incomplete\|sizeless}0 type %1...".
2073	template <typename... Ts>
2074	class SizelessTypeDiagnoser : public BoundTypeDiagnoser<Ts...> {
2075	public:
2076	SizelessTypeDiagnoser(unsigned DiagID, const Ts &... Args)
2077	: BoundTypeDiagnoser<Ts...>(DiagID, Args...) {}
2078
2079	void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
2080	const SemaDiagnosticBuilder &DB = S.Diag(Loc, this->DiagID);
2081	this->emit(DB, std::index_sequence_for<Ts...>());
2082	DB << T ->isSizelessType() << T;
2083	}
2084	};
2085
2086	enum class CompleteTypeKind {
2087	/// Apply the normal rules for complete types. In particular,
2088	/// treat all sizeless types as incomplete.
2089	Normal,
2090
2091	/// Relax the normal rules for complete types so that they include
2092	/// sizeless built-in types.
2093	AcceptSizeless,
2094
2095	// FIXME: Eventually we should flip the default to Normal and opt in
2096	// to AcceptSizeless rather than opt out of it.
2097	Default = AcceptSizeless
2098	};
2099
2100	private:
2101	/// Methods for marking which expressions involve dereferencing a pointer
2102	/// marked with the 'noderef' attribute. Expressions are checked bottom up as
2103	/// they are parsed, meaning that a noderef pointer may not be accessed. For
2104	/// example, in `&p` where `p` is a noderef pointer, we will first parse the*
2105	/// `p`, but need to check that `address of` is called on it. This requires*
2106	/// keeping a container of all pending expressions and checking if the address
2107	/// of them are eventually taken.
2108	void CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E);
2109	void CheckAddressOfNoDeref(const Expr *E);
2110	void CheckMemberAccessOfNoDeref(const MemberExpr *E);
2111
2112	bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
2113	CompleteTypeKind Kind, TypeDiagnoser *Diagnoser);
2114
2115	struct ModuleScope {
2116	SourceLocation BeginLoc;
2117	clang::Module Module = nullptr*;
2118	bool ModuleInterface = false;
2119	bool ImplicitGlobalModuleFragment = false;
2120	VisibleModuleSet OuterVisibleModules;
2121	};
2122	/// The modules we're currently parsing.
2123	llvm::SmallVector<ModuleScope, `16`> ModuleScopes;
2124
2125	/// Namespace definitions that we will export when they finish.
2126	llvm::SmallPtrSet<const NamespaceDecl*, `8`> DeferredExportedNamespaces;
2127
2128	/// Get the module whose scope we are currently within.
2129	Module getCurrentModule() const* {
2130	return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
2131	}
2132
2133	VisibleModuleSet VisibleModules;
2134
2135	public:
2136	/// Get the module owning an entity.
2137	Module getOwningModule(const* Decl *Entity) {
2138	return Entity->getOwningModule();
2139	}
2140
2141	/// Make a merged definition of an existing hidden definition \p ND
2142	/// visible at the specified location.
2143	void makeMergedDefinitionVisible(NamedDecl *ND);
2144
2145	bool isModuleVisible(const Module M, bool* ModulePrivate = false);
2146
2147	// When loading a non-modular PCH files, this is used to restore module
2148	// visibility.
2149	void makeModuleVisible(Module *Mod, SourceLocation ImportLoc) {
2150	VisibleModules.setVisible(Mod, ImportLoc);
2151	}
2152
2153	/// Determine whether a declaration is visible to name lookup.
2154	bool isVisible(const NamedDecl *D) {
2155	return D->isUnconditionallyVisible() \|\| isVisibleSlow(D);
2156	}
2157
2158	/// Determine whether any declaration of an entity is visible.
2159	bool
2160	hasVisibleDeclaration(const NamedDecl *D,
2161	llvm::SmallVectorImpl<Module > Modules = nullptr) {
2162	return isVisible(D) \|\| hasVisibleDeclarationSlow(D, Modules);
2163	}
2164	bool hasVisibleDeclarationSlow(const NamedDecl *D,
2165	llvm::SmallVectorImpl<Module > Modules);
2166
2167	bool hasVisibleMergedDefinition(NamedDecl *Def);
2168	bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
2169
2170	/// Determine if \p D and \p Suggested have a structurally compatible
2171	/// layout as described in C11 6.2.7/1.
2172	bool hasStructuralCompatLayout(Decl D, Decl Suggested);
2173
2174	/// Determine if \p D has a visible definition. If not, suggest a declaration
2175	/// that should be made visible to expose the definition.
2176	bool hasVisibleDefinition(NamedDecl D, NamedDecl *Suggested,
2177	bool OnlyNeedComplete = false);
2178	bool hasVisibleDefinition(const NamedDecl *D) {
2179	NamedDecl *Hidden;
2180	return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
2181	}
2182
2183	/// Determine if the template parameter \p D has a visible default argument.
2184	bool
2185	hasVisibleDefaultArgument(const NamedDecl *D,
2186	llvm::SmallVectorImpl<Module > Modules = nullptr);
2187
2188	/// Determine if there is a visible declaration of \p D that is an explicit
2189	/// specialization declaration for a specialization of a template. (For a
2190	/// member specialization, use hasVisibleMemberSpecialization.)
2191	bool hasVisibleExplicitSpecialization(
2192	const NamedDecl D, llvm::SmallVectorImpl<Module > Modules = nullptr*);
2193
2194	/// Determine if there is a visible declaration of \p D that is a member
2195	/// specialization declaration (as opposed to an instantiated declaration).
2196	bool hasVisibleMemberSpecialization(
2197	const NamedDecl D, llvm::SmallVectorImpl<Module > Modules = nullptr*);
2198
2199	/// Determine if \p A and \p B are equivalent internal linkage declarations
2200	/// from different modules, and thus an ambiguity error can be downgraded to
2201	/// an extension warning.
2202	bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
2203	const NamedDecl *B);
2204	void diagnoseEquivalentInternalLinkageDeclarations(
2205	SourceLocation Loc, const NamedDecl *D,
2206	ArrayRef<const NamedDecl *> Equiv);
2207
2208	bool isUsualDeallocationFunction(const CXXMethodDecl *FD);
2209
2210	bool isCompleteType(SourceLocation Loc, QualType T,
2211	CompleteTypeKind Kind = CompleteTypeKind::Default) {
2212	return !RequireCompleteTypeImpl(Loc, T, Kind, nullptr);
2213	}
2214	bool RequireCompleteType(SourceLocation Loc, QualType T,
2215	CompleteTypeKind Kind, TypeDiagnoser &Diagnoser);
2216	bool RequireCompleteType(SourceLocation Loc, QualType T,
2217	CompleteTypeKind Kind, unsigned DiagID);
2218
2219	bool RequireCompleteType(SourceLocation Loc, QualType T,
2220	TypeDiagnoser &Diagnoser) {
2221	return RequireCompleteType(Loc, T, CompleteTypeKind::Default, Diagnoser);
2222	}
2223	bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID) {
2224	return RequireCompleteType(Loc, T, CompleteTypeKind::Default, DiagID);
2225	}
2226
2227	template <typename... Ts>
2228	bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
2229	const Ts &...Args) {
2230	BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2231	return RequireCompleteType(Loc, T, Diagnoser);
2232	}
2233
2234	template <typename... Ts>
2235	bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID,
2236	const Ts &... Args) {
2237	SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2238	return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser);
2239	}
2240
2241	/// Get the type of expression E, triggering instantiation to complete the
2242	/// type if necessary -- that is, if the expression refers to a templated
2243	/// static data member of incomplete array type.
2244	///
2245	/// May still return an incomplete type if instantiation was not possible or
2246	/// if the type is incomplete for a different reason. Use
2247	/// RequireCompleteExprType instead if a diagnostic is expected for an
2248	/// incomplete expression type.
2249	QualType getCompletedType(Expr *E);
2250
2251	void completeExprArrayBound(Expr *E);
2252	bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
2253	TypeDiagnoser &Diagnoser);
2254	bool RequireCompleteExprType(Expr E, unsigned* DiagID);
2255
2256	template <typename... Ts>
2257	bool RequireCompleteExprType(Expr E, unsigned* DiagID, const Ts &...Args) {
2258	BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2259	return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
2260	}
2261
2262	template <typename... Ts>
2263	bool RequireCompleteSizedExprType(Expr E, unsigned* DiagID,
2264	const Ts &... Args) {
2265	SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2266	return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
2267	}
2268
2269	bool RequireLiteralType(SourceLocation Loc, QualType T,
2270	TypeDiagnoser &Diagnoser);
2271	bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
2272
2273	template <typename... Ts>
2274	bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
2275	const Ts &...Args) {
2276	BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2277	return RequireLiteralType(Loc, T, Diagnoser);
2278	}
2279
2280	QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
2281	const CXXScopeSpec &SS, QualType T,
2282	TagDecl OwnedTagDecl = nullptr*);
2283
2284	QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
2285	/// If AsUnevaluated is false, E is treated as though it were an evaluated
2286	/// context, such as when building a type for decltype(auto).
2287	QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
2288	bool AsUnevaluated = true);
2289	QualType BuildUnaryTransformType(QualType BaseType,
2290	UnaryTransformType::UTTKind UKind,
2291	SourceLocation Loc);
2292
2293	//===--------------------------------------------------------------------===//
2294	// Symbol table / Decl tracking callbacks: SemaDecl.cpp.
2295	//
2296
2297	struct SkipBodyInfo {
2298	SkipBodyInfo()
2299	: ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr),
2300	New(nullptr) {}
2301	bool ShouldSkip;
2302	bool CheckSameAsPrevious;
2303	NamedDecl *Previous;
2304	NamedDecl *New;
2305	};
2306
2307	DeclGroupPtrTy ConvertDeclToDeclGroup(Decl Ptr, Decl OwnedType = nullptr);
2308
2309	void DiagnoseUseOfUnimplementedSelectors();
2310
2311	bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
2312
2313	ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
2314	Scope S, CXXScopeSpec SS = nullptr,
2315	bool isClassName = false, bool HasTrailingDot = false,
2316	ParsedType ObjectType = nullptr,
2317	bool IsCtorOrDtorName = false,
2318	bool WantNontrivialTypeSourceInfo = false,
2319	bool IsClassTemplateDeductionContext = true,
2320	IdentifierInfo CorrectedII = nullptr**);
2321	TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
2322	bool isMicrosoftMissingTypename(const CXXScopeSpec SS, Scope S);
2323	void DiagnoseUnknownTypeName(IdentifierInfo *&II,
2324	SourceLocation IILoc,
2325	Scope *S,
2326	CXXScopeSpec *SS,
2327	ParsedType &SuggestedType,
2328	bool IsTemplateName = false);
2329
2330	/// Attempt to behave like MSVC in situations where lookup of an unqualified
2331	/// type name has failed in a dependent context. In these situations, we
2332	/// automatically form a DependentTypeName that will retry lookup in a related
2333	/// scope during instantiation.
2334	ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
2335	SourceLocation NameLoc,
2336	bool IsTemplateTypeArg);
2337
2338	/// Describes the result of the name lookup and resolution performed
2339	/// by \c ClassifyName().
2340	enum NameClassificationKind {
2341	/// This name is not a type or template in this context, but might be
2342	/// something else.
2343	NC_Unknown,
2344	/// Classification failed; an error has been produced.
2345	NC_Error,
2346	/// The name has been typo-corrected to a keyword.
2347	NC_Keyword,
2348	/// The name was classified as a type.
2349	NC_Type,
2350	/// The name was classified as a specific non-type, non-template
2351	/// declaration. ActOnNameClassifiedAsNonType should be called to
2352	/// convert the declaration to an expression.
2353	NC_NonType,
2354	/// The name was classified as an ADL-only function name.
2355	/// ActOnNameClassifiedAsUndeclaredNonType should be called to convert the
2356	/// result to an expression.
2357	NC_UndeclaredNonType,
2358	/// The name denotes a member of a dependent type that could not be
2359	/// resolved. ActOnNameClassifiedAsDependentNonType should be called to
2360	/// convert the result to an expression.
2361	NC_DependentNonType,
2362	/// The name was classified as an overload set, and an expression
2363	/// representing that overload set has been formed.
2364	/// ActOnNameClassifiedAsOverloadSet should be called to form a suitable
2365	/// expression referencing the overload set.
2366	NC_OverloadSet,
2367	/// The name was classified as a template whose specializations are types.
2368	NC_TypeTemplate,
2369	/// The name was classified as a variable template name.
2370	NC_VarTemplate,
2371	/// The name was classified as a function template name.
2372	NC_FunctionTemplate,
2373	/// The name was classified as an ADL-only function template name.
2374	NC_UndeclaredTemplate,
2375	/// The name was classified as a concept name.
2376	NC_Concept,
2377	};
2378
2379	class NameClassification {
2380	NameClassificationKind Kind;
2381	union {
2382	ExprResult Expr;
2383	NamedDecl *NonTypeDecl;
2384	TemplateName Template;
2385	ParsedType Type;
2386	};
2387
2388	explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
2389
2390	public:
2391	NameClassification(ParsedType Type) : Kind(NC_Type), Type (Type) {}
2392
2393	NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {}
2394
2395	static NameClassification Error() {
2396	return NameClassification (NC_Error);
2397	}
2398
2399	static NameClassification Unknown() {
2400	return NameClassification (NC_Unknown);
2401	}
2402
2403	static NameClassification OverloadSet(ExprResult E) {
2404	NameClassification Result(NC_OverloadSet);
2405	Result.Expr = E;
2406	return Result;
2407	}
2408
2409	static NameClassification NonType(NamedDecl *D) {
2410	NameClassification Result(NC_NonType);
2411	Result.NonTypeDecl = D;
2412	return Result;
2413	}
2414
2415	static NameClassification UndeclaredNonType() {
2416	return NameClassification (NC_UndeclaredNonType);
2417	}
2418
2419	static NameClassification DependentNonType() {
2420	return NameClassification (NC_DependentNonType);
2421	}
2422
2423	static NameClassification TypeTemplate(TemplateName Name) {
2424	NameClassification Result(NC_TypeTemplate);
2425	Result.Template = Name;
2426	return Result;
2427	}
2428
2429	static NameClassification VarTemplate(TemplateName Name) {
2430	NameClassification Result(NC_VarTemplate);
2431	Result.Template = Name;
2432	return Result;
2433	}
2434
2435	static NameClassification FunctionTemplate(TemplateName Name) {
2436	NameClassification Result(NC_FunctionTemplate);
2437	Result.Template = Name;
2438	return Result;
2439	}
2440
2441	static NameClassification Concept(TemplateName Name) {
2442	NameClassification Result(NC_Concept);
2443	Result.Template = Name;
2444	return Result;
2445	}
2446
2447	static NameClassification UndeclaredTemplate(TemplateName Name) {
2448	NameClassification Result(NC_UndeclaredTemplate);
2449	Result.Template = Name;
2450	return Result;
2451	}
2452
2453	NameClassificationKind getKind() const { return Kind; }
2454
2455	ExprResult getExpression() const {
2456	assert(Kind == NC_OverloadSet);
2457	return Expr;
2458	}
2459
2460	ParsedType getType() const {
2461	assert(Kind == NC_Type);
2462	return Type;
2463	}
2464
2465	NamedDecl getNonTypeDecl() const* {
2466	assert(Kind == NC_NonType);
2467	return NonTypeDecl;
2468	}
2469
2470	TemplateName getTemplateName() const {
2471	assert(Kind == NC_TypeTemplate \|\| Kind == NC_FunctionTemplate \|\|
2472	Kind == NC_VarTemplate \|\| Kind == NC_Concept \|\|
2473	Kind == NC_UndeclaredTemplate);
2474	return Template;
2475	}
2476
2477	TemplateNameKind getTemplateNameKind() const {
2478	switch (Kind) {
2479	case NC_TypeTemplate:
2480	return TNK_Type_template;
2481	case NC_FunctionTemplate:
2482	return TNK_Function_template;
2483	case NC_VarTemplate:
2484	return TNK_Var_template;
2485	case NC_Concept:
2486	return TNK_Concept_template;
2487	case NC_UndeclaredTemplate:
2488	return TNK_Undeclared_template;
2489	default:
2490	llvm_unreachable("unsupported name classification.");
2491	}
2492	}
2493	};
2494
2495	/// Perform name lookup on the given name, classifying it based on
2496	/// the results of name lookup and the following token.
2497	///
2498	/// This routine is used by the parser to resolve identifiers and help direct
2499	/// parsing. When the identifier cannot be found, this routine will attempt
2500	/// to correct the typo and classify based on the resulting name.
2501	///
2502	/// \param S The scope in which we're performing name lookup.
2503	///
2504	/// \param SS The nested-name-specifier that precedes the name.
2505	///
2506	/// \param Name The identifier. If typo correction finds an alternative name,
2507	/// this pointer parameter will be updated accordingly.
2508	///
2509	/// \param NameLoc The location of the identifier.
2510	///
2511	/// \param NextToken The token following the identifier. Used to help
2512	/// disambiguate the name.
2513	///
2514	/// \param CCC The correction callback, if typo correction is desired.
2515	NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS,
2516	IdentifierInfo *&Name, SourceLocation NameLoc,
2517	const Token &NextToken,
2518	CorrectionCandidateCallback CCC = nullptr*);
2519
2520	/// Act on the result of classifying a name as an undeclared (ADL-only)
2521	/// non-type declaration.
2522	ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name,
2523	SourceLocation NameLoc);
2524	/// Act on the result of classifying a name as an undeclared member of a
2525	/// dependent base class.
2526	ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS,
2527	IdentifierInfo *Name,
2528	SourceLocation NameLoc,
2529	bool IsAddressOfOperand);
2530	/// Act on the result of classifying a name as a specific non-type
2531	/// declaration.
2532	ExprResult ActOnNameClassifiedAsNonType(Scope S, const* CXXScopeSpec &SS,
2533	NamedDecl *Found,
2534	SourceLocation NameLoc,
2535	const Token &NextToken);
2536	/// Act on the result of classifying a name as an overload set.
2537	ExprResult ActOnNameClassifiedAsOverloadSet(Scope S, Expr OverloadSet);
2538
2539	/// Describes the detailed kind of a template name. Used in diagnostics.
2540	enum class TemplateNameKindForDiagnostics {
2541	ClassTemplate,
2542	FunctionTemplate,
2543	VarTemplate,
2544	AliasTemplate,
2545	TemplateTemplateParam,
2546	Concept,
2547	DependentTemplate
2548	};
2549	TemplateNameKindForDiagnostics
2550	getTemplateNameKindForDiagnostics(TemplateName Name);
2551
2552	/// Determine whether it's plausible that E was intended to be a
2553	/// template-name.
2554	bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent) {
2555	if (!getLangOpts().CPlusPlus \|\| E.isInvalid())
2556	return false;
2557	Dependent = false;
2558	if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
2559	return !DRE->hasExplicitTemplateArgs();
2560	if (auto *ME = dyn_cast<MemberExpr>(E.get()))
2561	return !ME->hasExplicitTemplateArgs();
2562	Dependent = true;
2563	if (auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.get()))
2564	return !DSDRE->hasExplicitTemplateArgs();
2565	if (auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.get()))
2566	return !DSME->hasExplicitTemplateArgs();
2567	// Any additional cases recognized here should also be handled by
2568	// diagnoseExprIntendedAsTemplateName.
2569	return false;
2570	}
2571	void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
2572	SourceLocation Less,
2573	SourceLocation Greater);
2574
2575	Decl ActOnDeclarator(Scope S, Declarator &D);
2576
2577	NamedDecl HandleDeclarator(Scope S, Declarator &D,
2578	MultiTemplateParamsArg TemplateParameterLists);
2579	void RegisterLocallyScopedExternCDecl(NamedDecl ND, Scope S);
2580	bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
2581	bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
2582	DeclarationName Name, SourceLocation Loc,
2583	bool IsTemplateId);
2584	void
2585	diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
2586	SourceLocation FallbackLoc,
2587	SourceLocation ConstQualLoc = SourceLocation (),
2588	SourceLocation VolatileQualLoc = SourceLocation (),
2589	SourceLocation RestrictQualLoc = SourceLocation (),
2590	SourceLocation AtomicQualLoc = SourceLocation (),
2591	SourceLocation UnalignedQualLoc = SourceLocation ());
2592
2593	static bool adjustContextForLocalExternDecl(DeclContext *&DC);
2594	void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
2595	NamedDecl getShadowedDeclaration(const* TypedefNameDecl *D,
2596	const LookupResult &R);
2597	NamedDecl getShadowedDeclaration(const* VarDecl D, const* LookupResult &R);
2598	void CheckShadow(NamedDecl D, NamedDecl ShadowedDecl,
2599	const LookupResult &R);
2600	void CheckShadow(Scope S, VarDecl D);
2601
2602	/// Warn if 'E', which is an expression that is about to be modified, refers
2603	/// to a shadowing declaration.
2604	void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
2605
2606	void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
2607
2608	private:
2609	/// Map of current shadowing declarations to shadowed declarations. Warn if
2610	/// it looks like the user is trying to modify the shadowing declaration.
2611	llvm::DenseMap<const NamedDecl , const* NamedDecl *> ShadowingDecls;
2612
2613	public:
2614	void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
2615	void handleTagNumbering(const TagDecl Tag, Scope TagScope);
2616	void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
2617	TypedefNameDecl *NewTD);
2618	void CheckTypedefForVariablyModifiedType(Scope S, TypedefNameDecl D);
2619	NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2620	TypeSourceInfo *TInfo,
2621	LookupResult &Previous);
2622	NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
2623	LookupResult &Previous, bool &Redeclaration);
2624	NamedDecl ActOnVariableDeclarator(Scope S, Declarator &D, DeclContext *DC,
2625	TypeSourceInfo *TInfo,
2626	LookupResult &Previous,
2627	MultiTemplateParamsArg TemplateParamLists,
2628	bool &AddToScope,
2629	ArrayRef<BindingDecl *> Bindings = None);
2630	NamedDecl *
2631	ActOnDecompositionDeclarator(Scope *S, Declarator &D,
2632	MultiTemplateParamsArg TemplateParamLists);
2633	// Returns true if the variable declaration is a redeclaration
2634	bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
2635	void CheckVariableDeclarationType(VarDecl *NewVD);
2636	bool DeduceVariableDeclarationType(VarDecl VDecl, bool* DirectInit,
2637	Expr *Init);
2638	void CheckCompleteVariableDeclaration(VarDecl *VD);
2639	void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
2640	void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
2641
2642	NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2643	TypeSourceInfo *TInfo,
2644	LookupResult &Previous,
2645	MultiTemplateParamsArg TemplateParamLists,
2646	bool &AddToScope);
2647	bool AddOverriddenMethods(CXXRecordDecl DC, CXXMethodDecl MD);
2648
2649	enum class CheckConstexprKind {
2650	/// Diagnose issues that are non-constant or that are extensions.
2651	Diagnose,
2652	/// Identify whether this function satisfies the formal rules for constexpr
2653	/// functions in the current lanugage mode (with no extensions).
2654	CheckValid
2655	};
2656
2657	bool CheckConstexprFunctionDefinition(const FunctionDecl *FD,
2658	CheckConstexprKind Kind);
2659
2660	void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
2661	void FindHiddenVirtualMethods(CXXMethodDecl *MD,
2662	SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2663	void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
2664	SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2665	// Returns true if the function declaration is a redeclaration
2666	bool CheckFunctionDeclaration(Scope *S,
2667	FunctionDecl *NewFD, LookupResult &Previous,
2668	bool IsMemberSpecialization);
2669	bool shouldLinkDependentDeclWithPrevious(Decl D, Decl OldDecl);
2670	bool canFullyTypeCheckRedeclaration(ValueDecl NewD, ValueDecl OldD,
2671	QualType NewT, QualType OldT);
2672	void CheckMain(FunctionDecl FD, const* DeclSpec &D);
2673	void CheckMSVCRTEntryPoint(FunctionDecl *FD);
2674	Attr getImplicitCodeSegOrSectionAttrForFunction(const* FunctionDecl *FD,
2675	bool IsDefinition);
2676	void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D);
2677	Decl ActOnParamDeclarator(Scope S, Declarator &D);
2678	ParmVarDecl BuildParmVarDeclForTypedef(DeclContext DC,
2679	SourceLocation Loc,
2680	QualType T);
2681	ParmVarDecl CheckParameter(DeclContext DC, SourceLocation StartLoc,
2682	SourceLocation NameLoc, IdentifierInfo *Name,
2683	QualType T, TypeSourceInfo *TSInfo,
2684	StorageClass SC);
2685	void ActOnParamDefaultArgument(Decl *param,
2686	SourceLocation EqualLoc,
2687	Expr *defarg);
2688	void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc,
2689	SourceLocation ArgLoc);
2690	void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
2691	ExprResult ConvertParamDefaultArgument(const ParmVarDecl *Param,
2692	Expr *DefaultArg,
2693	SourceLocation EqualLoc);
2694	void SetParamDefaultArgument(ParmVarDecl Param, Expr DefaultArg,
2695	SourceLocation EqualLoc);
2696
2697	// Contexts where using non-trivial C union types can be disallowed. This is
2698	// passed to err_non_trivial_c_union_in_invalid_context.
2699	enum NonTrivialCUnionContext {
2700	// Function parameter.
2701	NTCUC_FunctionParam,
2702	// Function return.
2703	NTCUC_FunctionReturn,
2704	// Default-initialized object.
2705	NTCUC_DefaultInitializedObject,
2706	// Variable with automatic storage duration.
2707	NTCUC_AutoVar,
2708	// Initializer expression that might copy from another object.
2709	NTCUC_CopyInit,
2710	// Assignment.
2711	NTCUC_Assignment,
2712	// Compound literal.
2713	NTCUC_CompoundLiteral,
2714	// Block capture.
2715	NTCUC_BlockCapture,
2716	// lvalue-to-rvalue conversion of volatile type.
2717	NTCUC_LValueToRValueVolatile,
2718	};
2719
2720	/// Emit diagnostics if the initializer or any of its explicit or
2721	/// implicitly-generated subexpressions require copying or
2722	/// default-initializing a type that is or contains a C union type that is
2723	/// non-trivial to copy or default-initialize.
2724	void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);
2725
2726	// These flags are passed to checkNonTrivialCUnion.
2727	enum NonTrivialCUnionKind {
2728	NTCUK_Init = `0x1`,
2729	NTCUK_Destruct = `0x2`,
2730	NTCUK_Copy = `0x4`,
2731	};
2732
2733	/// Emit diagnostics if a non-trivial C union type or a struct that contains
2734	/// a non-trivial C union is used in an invalid context.
2735	void checkNonTrivialCUnion(QualType QT, SourceLocation Loc,
2736	NonTrivialCUnionContext UseContext,
2737	unsigned NonTrivialKind);
2738
2739	void AddInitializerToDecl(Decl dcl, Expr init, bool DirectInit);
2740	void ActOnUninitializedDecl(Decl *dcl);
2741	void ActOnInitializerError(Decl *Dcl);
2742
2743	void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
2744	void ActOnCXXForRangeDecl(Decl *D);
2745	StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
2746	IdentifierInfo *Ident,
2747	ParsedAttributes &Attrs,
2748	SourceLocation AttrEnd);
2749	void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
2750	void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
2751	void CheckStaticLocalForDllExport(VarDecl *VD);
2752	void FinalizeDeclaration(Decl *D);
2753	DeclGroupPtrTy FinalizeDeclaratorGroup(Scope S, const* DeclSpec &DS,
2754	ArrayRef<Decl *> Group);
2755	DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
2756
2757	/// Should be called on all declarations that might have attached
2758	/// documentation comments.
2759	void ActOnDocumentableDecl(Decl *D);
2760	void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
2761
2762	void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
2763	SourceLocation LocAfterDecls);
2764	void CheckForFunctionRedefinition(
2765	FunctionDecl FD, const* FunctionDecl EffectiveDefinition = nullptr*,
2766	SkipBodyInfo SkipBody = nullptr*);
2767	Decl ActOnStartOfFunctionDef(Scope S, Declarator &D,
2768	MultiTemplateParamsArg TemplateParamLists,
2769	SkipBodyInfo SkipBody = nullptr*);
2770	Decl ActOnStartOfFunctionDef(Scope S, Decl *D,
2771	SkipBodyInfo SkipBody = nullptr*);
2772	void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D);
2773	ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr);
2774	ExprResult ActOnRequiresClause(ExprResult ConstraintExpr);
2775	void ActOnStartOfObjCMethodDef(Scope S, Decl D);
2776	bool isObjCMethodDecl(Decl *D) {
2777	return D && isa<ObjCMethodDecl>(D);
2778	}
2779
2780	/// Determine whether we can delay parsing the body of a function or
2781	/// function template until it is used, assuming we don't care about emitting
2782	/// code for that function.
2783	///
2784	/// This will be \c false if we may need the body of the function in the
2785	/// middle of parsing an expression (where it's impractical to switch to
2786	/// parsing a different function), for instance, if it's constexpr in C++11
2787	/// or has an 'auto' return type in C++14. These cases are essentially bugs.
2788	bool canDelayFunctionBody(const Declarator &D);
2789
2790	/// Determine whether we can skip parsing the body of a function
2791	/// definition, assuming we don't care about analyzing its body or emitting
2792	/// code for that function.
2793	///
2794	/// This will be \c false only if we may need the body of the function in
2795	/// order to parse the rest of the program (for instance, if it is
2796	/// \c constexpr in C++11 or has an 'auto' return type in C++14).
2797	bool canSkipFunctionBody(Decl *D);
2798
2799	void computeNRVO(Stmt Body, sema::FunctionScopeInfo Scope);
2800	Decl ActOnFinishFunctionBody(Decl Decl, Stmt *Body);
2801	Decl ActOnFinishFunctionBody(Decl Decl, Stmt Body, bool* IsInstantiation);
2802	Decl ActOnSkippedFunctionBody(Decl Decl);
2803	void ActOnFinishInlineFunctionDef(FunctionDecl *D);
2804
2805	/// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
2806	/// attribute for which parsing is delayed.
2807	void ActOnFinishDelayedAttribute(Scope S, Decl D, ParsedAttributes &Attrs);
2808
2809	/// Diagnose any unused parameters in the given sequence of
2810	/// ParmVarDecl pointers.
2811	void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);
2812
2813	/// Diagnose whether the size of parameters or return value of a
2814	/// function or obj-c method definition is pass-by-value and larger than a
2815	/// specified threshold.
2816	void
2817	DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,
2818	QualType ReturnTy, NamedDecl *D);
2819
2820	void DiagnoseInvalidJumps(Stmt *Body);
2821	Decl ActOnFileScopeAsmDecl(Expr expr,
2822	SourceLocation AsmLoc,
2823	SourceLocation RParenLoc);
2824
2825	/// Handle a C++11 empty-declaration and attribute-declaration.
2826	Decl ActOnEmptyDeclaration(Scope S, const ParsedAttributesView &AttrList,
2827	SourceLocation SemiLoc);
2828
2829	enum class ModuleDeclKind {
2830	Interface, ///< 'export module X;'
2831	Implementation, ///< 'module X;'
2832	};
2833
2834	/// The parser has processed a module-declaration that begins the definition
2835	/// of a module interface or implementation.
2836	DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
2837	SourceLocation ModuleLoc, ModuleDeclKind MDK,
2838	ModuleIdPath Path, bool IsFirstDecl);
2839
2840	/// The parser has processed a global-module-fragment declaration that begins
2841	/// the definition of the global module fragment of the current module unit.
2842	/// \param ModuleLoc The location of the 'module' keyword.
2843	DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc);
2844
2845	/// The parser has processed a private-module-fragment declaration that begins
2846	/// the definition of the private module fragment of the current module unit.
2847	/// \param ModuleLoc The location of the 'module' keyword.
2848	/// \param PrivateLoc The location of the 'private' keyword.
2849	DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
2850	SourceLocation PrivateLoc);
2851
2852	/// The parser has processed a module import declaration.
2853	///
2854	/// \param StartLoc The location of the first token in the declaration. This
2855	/// could be the location of an '@', 'export', or 'import'.
2856	/// \param ExportLoc The location of the 'export' keyword, if any.
2857	/// \param ImportLoc The location of the 'import' keyword.
2858	/// \param Path The module access path.
2859	DeclResult ActOnModuleImport(SourceLocation StartLoc,
2860	SourceLocation ExportLoc,
2861	SourceLocation ImportLoc, ModuleIdPath Path);
2862	DeclResult ActOnModuleImport(SourceLocation StartLoc,
2863	SourceLocation ExportLoc,
2864	SourceLocation ImportLoc, Module *M,
2865	ModuleIdPath Path = {});
2866
2867	/// The parser has processed a module import translated from a
2868	/// #include or similar preprocessing directive.
2869	void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2870	void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2871
2872	/// The parsed has entered a submodule.
2873	void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
2874	/// The parser has left a submodule.
2875	void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);
2876
2877	/// Create an implicit import of the given module at the given
2878	/// source location, for error recovery, if possible.
2879	///
2880	/// This routine is typically used when an entity found by name lookup
2881	/// is actually hidden within a module that we know about but the user
2882	/// has forgotten to import.
2883	void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
2884	Module *Mod);
2885
2886	/// Kinds of missing import. Note, the values of these enumerators correspond
2887	/// to %select values in diagnostics.
2888	enum class MissingImportKind {
2889	Declaration,
2890	Definition,
2891	DefaultArgument,
2892	ExplicitSpecialization,
2893	PartialSpecialization
2894	};
2895
2896	/// Diagnose that the specified declaration needs to be visible but
2897	/// isn't, and suggest a module import that would resolve the problem.
2898	void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2899	MissingImportKind MIK, bool Recover = true);
2900	void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2901	SourceLocation DeclLoc, ArrayRef<Module *> Modules,
2902	MissingImportKind MIK, bool Recover);
2903
2904	Decl ActOnStartExportDecl(Scope S, SourceLocation ExportLoc,
2905	SourceLocation LBraceLoc);
2906	Decl ActOnFinishExportDecl(Scope S, Decl *ExportDecl,
2907	SourceLocation RBraceLoc);
2908
2909	/// We've found a use of a templated declaration that would trigger an
2910	/// implicit instantiation. Check that any relevant explicit specializations
2911	/// and partial specializations are visible, and diagnose if not.
2912	void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
2913
2914	/// Retrieve a suitable printing policy for diagnostics.
2915	PrintingPolicy getPrintingPolicy() const {
2916	return getPrintingPolicy(Context, PP);
2917	}
2918
2919	/// Retrieve a suitable printing policy for diagnostics.
2920	static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
2921	const Preprocessor &PP);
2922
2923	/// Scope actions.
2924	void ActOnPopScope(SourceLocation Loc, Scope *S);
2925	void ActOnTranslationUnitScope(Scope *S);
2926
2927	Decl ParsedFreeStandingDeclSpec(Scope S, AccessSpecifier AS, DeclSpec &DS,
2928	RecordDecl *&AnonRecord);
2929	Decl ParsedFreeStandingDeclSpec(Scope S, AccessSpecifier AS, DeclSpec &DS,
2930	MultiTemplateParamsArg TemplateParams,
2931	bool IsExplicitInstantiation,
2932	RecordDecl *&AnonRecord);
2933
2934	Decl BuildAnonymousStructOrUnion(Scope S, DeclSpec &DS,
2935	AccessSpecifier AS,
2936	RecordDecl *Record,
2937	const PrintingPolicy &Policy);
2938
2939	Decl BuildMicrosoftCAnonymousStruct(Scope S, DeclSpec &DS,
2940	RecordDecl *Record);
2941
2942	/// Common ways to introduce type names without a tag for use in diagnostics.
2943	/// Keep in sync with err_tag_reference_non_tag.
2944	enum NonTagKind {
2945	NTK_NonStruct,
2946	NTK_NonClass,
2947	NTK_NonUnion,
2948	NTK_NonEnum,
2949	NTK_Typedef,
2950	NTK_TypeAlias,
2951	NTK_Template,
2952	NTK_TypeAliasTemplate,
2953	NTK_TemplateTemplateArgument,
2954	};
2955
2956	/// Given a non-tag type declaration, returns an enum useful for indicating
2957	/// what kind of non-tag type this is.
2958	NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);
2959
2960	bool isAcceptableTagRedeclaration(const TagDecl *Previous,
2961	TagTypeKind NewTag, bool isDefinition,
2962	SourceLocation NewTagLoc,
2963	const IdentifierInfo *Name);
2964
2965	enum TagUseKind {
2966	TUK_Reference, // Reference to a tag: 'struct foo X;'*
2967	TUK_Declaration, // Fwd decl of a tag: 'struct foo;'
2968	TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'
2969	TUK_Friend // Friend declaration: 'friend struct foo;'
2970	};
2971
2972	Decl ActOnTag(Scope S, unsigned TagSpec, TagUseKind TUK,
2973	SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,
2974	SourceLocation NameLoc, const ParsedAttributesView &Attr,
2975	AccessSpecifier AS, SourceLocation ModulePrivateLoc,
2976	MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,
2977	bool &IsDependent, SourceLocation ScopedEnumKWLoc,
2978	bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
2979	bool IsTypeSpecifier, bool IsTemplateParamOrArg,
2980	SkipBodyInfo SkipBody = nullptr*);
2981
2982	Decl ActOnTemplatedFriendTag(Scope S, SourceLocation FriendLoc,
2983	unsigned TagSpec, SourceLocation TagLoc,
2984	CXXScopeSpec &SS, IdentifierInfo *Name,
2985	SourceLocation NameLoc,
2986	const ParsedAttributesView &Attr,
2987	MultiTemplateParamsArg TempParamLists);
2988
2989	TypeResult ActOnDependentTag(Scope *S,
2990	unsigned TagSpec,
2991	TagUseKind TUK,
2992	const CXXScopeSpec &SS,
2993	IdentifierInfo *Name,
2994	SourceLocation TagLoc,
2995	SourceLocation NameLoc);
2996
2997	void ActOnDefs(Scope S, Decl TagD, SourceLocation DeclStart,
2998	IdentifierInfo *ClassName,
2999	SmallVectorImpl<Decl *> &Decls);
3000	Decl ActOnField(Scope S, Decl *TagD, SourceLocation DeclStart,
3001	Declarator &D, Expr *BitfieldWidth);
3002
3003	FieldDecl HandleField(Scope S, RecordDecl *TagD, SourceLocation DeclStart,
3004	Declarator &D, Expr *BitfieldWidth,
3005	InClassInitStyle InitStyle,
3006	AccessSpecifier AS);
3007	MSPropertyDecl HandleMSProperty(Scope S, RecordDecl *TagD,
3008	SourceLocation DeclStart, Declarator &D,
3009	Expr *BitfieldWidth,
3010	InClassInitStyle InitStyle,
3011	AccessSpecifier AS,
3012	const ParsedAttr &MSPropertyAttr);
3013
3014	FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
3015	TypeSourceInfo *TInfo,
3016	RecordDecl *Record, SourceLocation Loc,
3017	bool Mutable, Expr *BitfieldWidth,
3018	InClassInitStyle InitStyle,
3019	SourceLocation TSSL,
3020	AccessSpecifier AS, NamedDecl *PrevDecl,
3021	Declarator D = nullptr*);
3022
3023	bool CheckNontrivialField(FieldDecl *FD);
3024	void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);
3025
3026	enum TrivialABIHandling {
3027	/// The triviality of a method unaffected by "trivial_abi".
3028	TAH_IgnoreTrivialABI,
3029
3030	/// The triviality of a method affected by "trivial_abi".
3031	TAH_ConsiderTrivialABI
3032	};
3033
3034	bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
3035	TrivialABIHandling TAH = TAH_IgnoreTrivialABI,
3036	bool Diagnose = false);
3037
3038	/// For a defaulted function, the kind of defaulted function that it is.
3039	class DefaultedFunctionKind {
3040	CXXSpecialMember SpecialMember : `8`;
3041	DefaultedComparisonKind Comparison : `8`;
3042
3043	public:
3044	DefaultedFunctionKind()
3045	: SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) {
3046	}
3047	DefaultedFunctionKind(CXXSpecialMember CSM)
3048	: SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {}
3049	DefaultedFunctionKind(DefaultedComparisonKind Comp)
3050	: SpecialMember(CXXInvalid), Comparison(Comp) {}
3051
3052	bool isSpecialMember() const { return SpecialMember != CXXInvalid; }
3053	bool isComparison() const {
3054	return Comparison != DefaultedComparisonKind::None;
3055	}
3056
3057	explicit operator bool() const {
3058	return isSpecialMember() \|\| isComparison();
3059	}
3060
3061	CXXSpecialMember asSpecialMember() const { return SpecialMember; }
3062	DefaultedComparisonKind asComparison() const { return Comparison; }
3063
3064	/// Get the index of this function kind for use in diagnostics.
3065	unsigned getDiagnosticIndex() const {
3066	static_assert(CXXInvalid > CXXDestructor,
3067	"invalid should have highest index");
3068	static_assert((unsigned)DefaultedComparisonKind::None == `0`,
3069	"none should be equal to zero");
3070	return SpecialMember + (unsigned)Comparison;
3071	}
3072	};
3073
3074	DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD);
3075
3076	CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) {
3077	return getDefaultedFunctionKind(MD).asSpecialMember();
3078	}
3079	DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) {
3080	return getDefaultedFunctionKind(FD).asComparison();
3081	}
3082
3083	void ActOnLastBitfield(SourceLocation DeclStart,
3084	SmallVectorImpl<Decl *> &AllIvarDecls);
3085	Decl ActOnIvar(Scope S, SourceLocation DeclStart,
3086	Declarator &D, Expr *BitfieldWidth,
3087	tok::ObjCKeywordKind visibility);
3088
3089	// This is used for both record definitions and ObjC interface declarations.
3090	void ActOnFields(Scope S, SourceLocation RecLoc, Decl TagDecl,
3091	ArrayRef<Decl *> Fields, SourceLocation LBrac,
3092	SourceLocation RBrac, const ParsedAttributesView &AttrList);
3093
3094	/// ActOnTagStartDefinition - Invoked when we have entered the
3095	/// scope of a tag's definition (e.g., for an enumeration, class,
3096	/// struct, or union).
3097	void ActOnTagStartDefinition(Scope S, Decl TagDecl);
3098
3099	/// Perform ODR-like check for C/ObjC when merging tag types from modules.
3100	/// Differently from C++, actually parse the body and reject / error out
3101	/// in case of a structural mismatch.
3102	bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,
3103	SkipBodyInfo &SkipBody);
3104
3105	typedef void *SkippedDefinitionContext;
3106
3107	/// Invoked when we enter a tag definition that we're skipping.
3108	SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope S, Decl TD);
3109
3110	Decl ActOnObjCContainerStartDefinition(Decl IDecl);
3111
3112	/// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
3113	/// C++ record definition's base-specifiers clause and are starting its
3114	/// member declarations.
3115	void ActOnStartCXXMemberDeclarations(Scope S, Decl TagDecl,
3116	SourceLocation FinalLoc,
3117	bool IsFinalSpelledSealed,
3118	SourceLocation LBraceLoc);
3119
3120	/// ActOnTagFinishDefinition - Invoked once we have finished parsing
3121	/// the definition of a tag (enumeration, class, struct, or union).
3122	void ActOnTagFinishDefinition(Scope S, Decl TagDecl,
3123	SourceRange BraceRange);
3124
3125	void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);
3126
3127	void ActOnObjCContainerFinishDefinition();
3128
3129	/// Invoked when we must temporarily exit the objective-c container
3130	/// scope for parsing/looking-up C constructs.
3131	///
3132	/// Must be followed by a call to \see ActOnObjCReenterContainerContext
3133	void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);
3134	void ActOnObjCReenterContainerContext(DeclContext *DC);
3135
3136	/// ActOnTagDefinitionError - Invoked when there was an unrecoverable
3137	/// error parsing the definition of a tag.
3138	void ActOnTagDefinitionError(Scope S, Decl TagDecl);
3139
3140	EnumConstantDecl CheckEnumConstant(EnumDecl Enum,
3141	EnumConstantDecl *LastEnumConst,
3142	SourceLocation IdLoc,
3143	IdentifierInfo *Id,
3144	Expr *val);
3145	bool CheckEnumUnderlyingType(TypeSourceInfo *TI);
3146	bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
3147	QualType EnumUnderlyingTy, bool IsFixed,
3148	const EnumDecl *Prev);
3149
3150	/// Determine whether the body of an anonymous enumeration should be skipped.
3151	/// \param II The name of the first enumerator.
3152	SkipBodyInfo shouldSkipAnonEnumBody(Scope S, IdentifierInfo II,
3153	SourceLocation IILoc);
3154
3155	Decl ActOnEnumConstant(Scope S, Decl EnumDecl, Decl LastEnumConstant,
3156	SourceLocation IdLoc, IdentifierInfo *Id,
3157	const ParsedAttributesView &Attrs,
3158	SourceLocation EqualLoc, Expr *Val);
3159	void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
3160	Decl EnumDecl, ArrayRef<Decl > Elements, Scope *S,
3161	const ParsedAttributesView &Attr);
3162
3163	/// Set the current declaration context until it gets popped.
3164	void PushDeclContext(Scope S, DeclContext DC);
3165	void PopDeclContext();
3166
3167	/// EnterDeclaratorContext - Used when we must lookup names in the context
3168	/// of a declarator's nested name specifier.
3169	void EnterDeclaratorContext(Scope S, DeclContext DC);
3170	void ExitDeclaratorContext(Scope *S);
3171
3172	/// Enter a template parameter scope, after it's been associated with a particular
3173	/// DeclContext. Causes lookup within the scope to chain through enclosing contexts
3174	/// in the correct order.
3175	void EnterTemplatedContext(Scope S, DeclContext DC);
3176
3177	/// Push the parameters of D, which must be a function, into scope.
3178	void ActOnReenterFunctionContext(Scope* S, Decl* D);
3179	void ActOnExitFunctionContext();
3180
3181	DeclContext *getFunctionLevelDeclContext();
3182
3183	/// getCurFunctionDecl - If inside of a function body, this returns a pointer
3184	/// to the function decl for the function being parsed. If we're currently
3185	/// in a 'block', this returns the containing context.
3186	FunctionDecl *getCurFunctionDecl();
3187
3188	/// getCurMethodDecl - If inside of a method body, this returns a pointer to
3189	/// the method decl for the method being parsed. If we're currently
3190	/// in a 'block', this returns the containing context.
3191	ObjCMethodDecl *getCurMethodDecl();
3192
3193	/// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
3194	/// or C function we're in, otherwise return null. If we're currently
3195	/// in a 'block', this returns the containing context.
3196	NamedDecl *getCurFunctionOrMethodDecl();
3197
3198	/// Add this decl to the scope shadowed decl chains.
3199	void PushOnScopeChains(NamedDecl D, Scope S, bool AddToContext = true);
3200
3201	/// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
3202	/// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
3203	/// true if 'D' belongs to the given declaration context.
3204	///
3205	/// \param AllowInlineNamespace If \c true, allow the declaration to be in the
3206	/// enclosing namespace set of the context, rather than contained
3207	/// directly within it.
3208	bool isDeclInScope(NamedDecl D, DeclContext Ctx, Scope S = nullptr*,
3209	bool AllowInlineNamespace = false);
3210
3211	/// Finds the scope corresponding to the given decl context, if it
3212	/// happens to be an enclosing scope. Otherwise return NULL.
3213	static Scope getScopeForDeclContext(Scope S, DeclContext *DC);
3214
3215	/// Subroutines of ActOnDeclarator().
3216	TypedefDecl ParseTypedefDecl(Scope S, Declarator &D, QualType T,
3217	TypeSourceInfo *TInfo);
3218	bool isIncompatibleTypedef(TypeDecl Old, TypedefNameDecl New);
3219
3220	/// Describes the kind of merge to perform for availability
3221	/// attributes (including "deprecated", "unavailable", and "availability").
3222	enum AvailabilityMergeKind {
3223	/// Don't merge availability attributes at all.
3224	AMK_None,
3225	/// Merge availability attributes for a redeclaration, which requires
3226	/// an exact match.
3227	AMK_Redeclaration,
3228	/// Merge availability attributes for an override, which requires
3229	/// an exact match or a weakening of constraints.
3230	AMK_Override,
3231	/// Merge availability attributes for an implementation of
3232	/// a protocol requirement.
3233	AMK_ProtocolImplementation,
3234	};
3235
3236	/// Describes the kind of priority given to an availability attribute.
3237	///
3238	/// The sum of priorities deteremines the final priority of the attribute.
3239	/// The final priority determines how the attribute will be merged.
3240	/// An attribute with a lower priority will always remove higher priority
3241	/// attributes for the specified platform when it is being applied. An
3242	/// attribute with a higher priority will not be applied if the declaration
3243	/// already has an availability attribute with a lower priority for the
3244	/// specified platform. The final prirority values are not expected to match
3245	/// the values in this enumeration, but instead should be treated as a plain
3246	/// integer value. This enumeration just names the priority weights that are
3247	/// used to calculate that final vaue.
3248	enum AvailabilityPriority : int {
3249	/// The availability attribute was specified explicitly next to the
3250	/// declaration.
3251	AP_Explicit = `0`,
3252
3253	/// The availability attribute was applied using '#pragma clang attribute'.
3254	AP_PragmaClangAttribute = `1`,
3255
3256	/// The availability attribute for a specific platform was inferred from
3257	/// an availability attribute for another platform.
3258	AP_InferredFromOtherPlatform = `2`
3259	};
3260
3261	/// Attribute merging methods. Return true if a new attribute was added.
3262	AvailabilityAttr *
3263	mergeAvailabilityAttr(NamedDecl D, const* AttributeCommonInfo &CI,
3264	IdentifierInfo Platform, bool* Implicit,
3265	VersionTuple Introduced, VersionTuple Deprecated,
3266	VersionTuple Obsoleted, bool IsUnavailable,
3267	StringRef Message, bool IsStrict, StringRef Replacement,
3268	AvailabilityMergeKind AMK, int Priority);
3269	TypeVisibilityAttr *
3270	mergeTypeVisibilityAttr(Decl D, const* AttributeCommonInfo &CI,
3271	TypeVisibilityAttr::VisibilityType Vis);
3272	VisibilityAttr mergeVisibilityAttr(Decl D, const AttributeCommonInfo &CI,
3273	VisibilityAttr::VisibilityType Vis);
3274	UuidAttr mergeUuidAttr(Decl D, const AttributeCommonInfo &CI,
3275	StringRef UuidAsWritten, MSGuidDecl *GuidDecl);
3276	DLLImportAttr mergeDLLImportAttr(Decl D, const AttributeCommonInfo &CI);
3277	DLLExportAttr mergeDLLExportAttr(Decl D, const AttributeCommonInfo &CI);
3278	MSInheritanceAttr mergeMSInheritanceAttr(Decl D,
3279	const AttributeCommonInfo &CI,
3280	bool BestCase,
3281	MSInheritanceModel Model);
3282	FormatAttr mergeFormatAttr(Decl D, const AttributeCommonInfo &CI,
3283	IdentifierInfo Format, int* FormatIdx,
3284	int FirstArg);
3285	SectionAttr mergeSectionAttr(Decl D, const AttributeCommonInfo &CI,
3286	StringRef Name);
3287	CodeSegAttr mergeCodeSegAttr(Decl D, const AttributeCommonInfo &CI,
3288	StringRef Name);
3289	AlwaysInlineAttr mergeAlwaysInlineAttr(Decl D,
3290	const AttributeCommonInfo &CI,
3291	const IdentifierInfo *Ident);
3292	MinSizeAttr mergeMinSizeAttr(Decl D, const AttributeCommonInfo &CI);
3293	NoSpeculativeLoadHardeningAttr *
3294	mergeNoSpeculativeLoadHardeningAttr(Decl *D,
3295	const NoSpeculativeLoadHardeningAttr &AL);
3296	SpeculativeLoadHardeningAttr *
3297	mergeSpeculativeLoadHardeningAttr(Decl *D,
3298	const SpeculativeLoadHardeningAttr &AL);
3299	SwiftNameAttr mergeSwiftNameAttr(Decl D, const SwiftNameAttr &SNA,
3300	StringRef Name);
3301	OptimizeNoneAttr mergeOptimizeNoneAttr(Decl D,
3302	const AttributeCommonInfo &CI);
3303	InternalLinkageAttr mergeInternalLinkageAttr(Decl D, const ParsedAttr &AL);
3304	InternalLinkageAttr mergeInternalLinkageAttr(Decl D,
3305	const InternalLinkageAttr &AL);
3306	CommonAttr mergeCommonAttr(Decl D, const ParsedAttr &AL);
3307	CommonAttr mergeCommonAttr(Decl D, const CommonAttr &AL);
3308	WebAssemblyImportNameAttr *mergeImportNameAttr(
3309	Decl D, const* WebAssemblyImportNameAttr &AL);
3310	WebAssemblyImportModuleAttr *mergeImportModuleAttr(
3311	Decl D, const* WebAssemblyImportModuleAttr &AL);
3312	EnforceTCBAttr mergeEnforceTCBAttr(Decl D, const EnforceTCBAttr &AL);
3313	EnforceTCBLeafAttr mergeEnforceTCBLeafAttr(Decl D,
3314	const EnforceTCBLeafAttr &AL);
3315
3316	void mergeDeclAttributes(NamedDecl New, Decl Old,
3317	AvailabilityMergeKind AMK = AMK_Redeclaration);
3318	void MergeTypedefNameDecl(Scope S, TypedefNameDecl New,
3319	LookupResult &OldDecls);
3320	bool MergeFunctionDecl(FunctionDecl New, NamedDecl &Old, Scope *S,
3321	bool MergeTypeWithOld);
3322	bool MergeCompatibleFunctionDecls(FunctionDecl New, FunctionDecl Old,
3323	Scope S, bool* MergeTypeWithOld);
3324	void mergeObjCMethodDecls(ObjCMethodDecl New, ObjCMethodDecl Old);
3325	void MergeVarDecl(VarDecl *New, LookupResult &Previous);
3326	void MergeVarDeclTypes(VarDecl New, VarDecl Old, bool MergeTypeWithOld);
3327	void MergeVarDeclExceptionSpecs(VarDecl New, VarDecl Old);
3328	bool checkVarDeclRedefinition(VarDecl OldDefn, VarDecl NewDefn);
3329	void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);
3330	bool MergeCXXFunctionDecl(FunctionDecl New, FunctionDecl Old, Scope *S);
3331
3332	// AssignmentAction - This is used by all the assignment diagnostic functions
3333	// to represent what is actually causing the operation
3334	enum AssignmentAction {
3335	AA_Assigning,
3336	AA_Passing,
3337	AA_Returning,
3338	AA_Converting,
3339	AA_Initializing,
3340	AA_Sending,
3341	AA_Casting,
3342	AA_Passing_CFAudited
3343	};
3344
3345	/// C++ Overloading.
3346	enum OverloadKind {
3347	/// This is a legitimate overload: the existing declarations are
3348	/// functions or function templates with different signatures.
3349	Ovl_Overload,
3350
3351	/// This is not an overload because the signature exactly matches
3352	/// an existing declaration.
3353	Ovl_Match,
3354
3355	/// This is not an overload because the lookup results contain a
3356	/// non-function.
3357	Ovl_NonFunction
3358	};
3359	OverloadKind CheckOverload(Scope *S,
3360	FunctionDecl *New,
3361	const LookupResult &OldDecls,
3362	NamedDecl *&OldDecl,
3363	bool IsForUsingDecl);
3364	bool IsOverload(FunctionDecl New, FunctionDecl Old, bool IsForUsingDecl,
3365	bool ConsiderCudaAttrs = true,
3366	bool ConsiderRequiresClauses = true);
3367
3368	enum class AllowedExplicit {
3369	/// Allow no explicit functions to be used.
3370	None,
3371	/// Allow explicit conversion functions but not explicit constructors.
3372	Conversions,
3373	/// Allow both explicit conversion functions and explicit constructors.
3374	All
3375	};
3376
3377	ImplicitConversionSequence
3378	TryImplicitConversion(Expr *From, QualType ToType,
3379	bool SuppressUserConversions,
3380	AllowedExplicit AllowExplicit,
3381	bool InOverloadResolution,
3382	bool CStyle,
3383	bool AllowObjCWritebackConversion);
3384
3385	bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
3386	bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
3387	bool IsComplexPromotion(QualType FromType, QualType ToType);
3388	bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
3389	bool InOverloadResolution,
3390	QualType& ConvertedType, bool &IncompatibleObjC);
3391	bool isObjCPointerConversion(QualType FromType, QualType ToType,
3392	QualType& ConvertedType, bool &IncompatibleObjC);
3393	bool isObjCWritebackConversion(QualType FromType, QualType ToType,
3394	QualType &ConvertedType);
3395	bool IsBlockPointerConversion(QualType FromType, QualType ToType,
3396	QualType& ConvertedType);
3397	bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
3398	const FunctionProtoType *NewType,
3399	unsigned ArgPos = nullptr*);
3400	void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
3401	QualType FromType, QualType ToType);
3402
3403	void maybeExtendBlockObject(ExprResult &E);
3404	CastKind PrepareCastToObjCObjectPointer(ExprResult &E);
3405	bool CheckPointerConversion(Expr *From, QualType ToType,
3406	CastKind &Kind,
3407	CXXCastPath& BasePath,
3408	bool IgnoreBaseAccess,
3409	bool Diagnose = true);
3410	bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
3411	bool InOverloadResolution,
3412	QualType &ConvertedType);
3413	bool CheckMemberPointerConversion(Expr *From, QualType ToType,
3414	CastKind &Kind,
3415	CXXCastPath &BasePath,
3416	bool IgnoreBaseAccess);
3417	bool IsQualificationConversion(QualType FromType, QualType ToType,
3418	bool CStyle, bool &ObjCLifetimeConversion);
3419	bool IsFunctionConversion(QualType FromType, QualType ToType,
3420	QualType &ResultTy);
3421	bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
3422	bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
3423
3424	ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
3425	const VarDecl *NRVOCandidate,
3426	QualType ResultType,
3427	Expr *Value,
3428	bool AllowNRVO = true);
3429
3430	bool CanPerformAggregateInitializationForOverloadResolution(
3431	const InitializedEntity &Entity, InitListExpr *From);
3432
3433	bool IsStringInit(Expr Init, const* ArrayType *AT);
3434
3435	bool CanPerformCopyInitialization(const InitializedEntity &Entity,
3436	ExprResult Init);
3437	ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
3438	SourceLocation EqualLoc,
3439	ExprResult Init,
3440	bool TopLevelOfInitList = false,
3441	bool AllowExplicit = false);
3442	ExprResult PerformObjectArgumentInitialization(Expr *From,
3443	NestedNameSpecifier *Qualifier,
3444	NamedDecl *FoundDecl,
3445	CXXMethodDecl *Method);
3446
3447	/// Check that the lifetime of the initializer (and its subobjects) is
3448	/// sufficient for initializing the entity, and perform lifetime extension
3449	/// (when permitted) if not.
3450	void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);
3451
3452	ExprResult PerformContextuallyConvertToBool(Expr *From);
3453	ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
3454
3455	/// Contexts in which a converted constant expression is required.
3456	enum CCEKind {
3457	CCEK_CaseValue, ///< Expression in a case label.
3458	CCEK_Enumerator, ///< Enumerator value with fixed underlying type.
3459	CCEK_TemplateArg, ///< Value of a non-type template parameter.
3460	CCEK_ArrayBound, ///< Array bound in array declarator or new-expression.
3461	CCEK_ConstexprIf, ///< Condition in a constexpr if statement.
3462	CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.
3463	};
3464	ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3465	llvm::APSInt &Value, CCEKind CCE);
3466	ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3467	APValue &Value, CCEKind CCE,
3468	NamedDecl Dest = nullptr*);
3469
3470	/// Abstract base class used to perform a contextual implicit
3471	/// conversion from an expression to any type passing a filter.
3472	class ContextualImplicitConverter {
3473	public:
3474	bool Suppress;
3475	bool SuppressConversion;
3476
3477	ContextualImplicitConverter(bool Suppress = false,
3478	bool SuppressConversion = false)
3479	: Suppress(Suppress), SuppressConversion(SuppressConversion) {}
3480
3481	/// Determine whether the specified type is a valid destination type
3482	/// for this conversion.
3483	virtual bool match(QualType T) = `0`;
3484
3485	/// Emits a diagnostic complaining that the expression does not have
3486	/// integral or enumeration type.
3487	virtual SemaDiagnosticBuilder
3488	diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = `0`;
3489
3490	/// Emits a diagnostic when the expression has incomplete class type.
3491	virtual SemaDiagnosticBuilder
3492	diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = `0`;
3493
3494	/// Emits a diagnostic when the only matching conversion function
3495	/// is explicit.
3496	virtual SemaDiagnosticBuilder diagnoseExplicitConv(
3497	Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = `0`;
3498
3499	/// Emits a note for the explicit conversion function.
3500	virtual SemaDiagnosticBuilder
3501	noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = `0`;
3502
3503	/// Emits a diagnostic when there are multiple possible conversion
3504	/// functions.
3505	virtual SemaDiagnosticBuilder
3506	diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = `0`;
3507
3508	/// Emits a note for one of the candidate conversions.
3509	virtual SemaDiagnosticBuilder
3510	noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = `0`;
3511
3512	/// Emits a diagnostic when we picked a conversion function
3513	/// (for cases when we are not allowed to pick a conversion function).
3514	virtual SemaDiagnosticBuilder diagnoseConversion(
3515	Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = `0`;
3516
3517	virtual ~ContextualImplicitConverter() {}
3518	};
3519
3520	class ICEConvertDiagnoser : public ContextualImplicitConverter {
3521	bool AllowScopedEnumerations;
3522
3523	public:
3524	ICEConvertDiagnoser(bool AllowScopedEnumerations,
3525	bool Suppress, bool SuppressConversion)
3526	: ContextualImplicitConverter (Suppress, SuppressConversion),
3527	AllowScopedEnumerations(AllowScopedEnumerations) {}
3528
3529	/// Match an integral or (possibly scoped) enumeration type.
3530	bool match(QualType T) override;
3531
3532	SemaDiagnosticBuilder
3533	diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override {
3534	return diagnoseNotInt(S, Loc, T);
3535	}
3536
3537	/// Emits a diagnostic complaining that the expression does not have
3538	/// integral or enumeration type.
3539	virtual SemaDiagnosticBuilder
3540	diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = `0`;
3541	};
3542
3543	/// Perform a contextual implicit conversion.
3544	ExprResult PerformContextualImplicitConversion(
3545	SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);
3546
3547
3548	enum ObjCSubscriptKind {
3549	OS_Array,
3550	OS_Dictionary,
3551	OS_Error
3552	};
3553	ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
3554
3555	// Note that LK_String is intentionally after the other literals, as
3556	// this is used for diagnostics logic.
3557	enum ObjCLiteralKind {
3558	LK_Array,
3559	LK_Dictionary,
3560	LK_Numeric,
3561	LK_Boxed,
3562	LK_String,
3563	LK_Block,
3564	LK_None
3565	};
3566	ObjCLiteralKind CheckLiteralKind(Expr *FromE);
3567
3568	ExprResult PerformObjectMemberConversion(Expr *From,
3569	NestedNameSpecifier *Qualifier,
3570	NamedDecl *FoundDecl,
3571	NamedDecl *Member);
3572
3573	// Members have to be NamespaceDecl or TranslationUnitDecl.
3574	// TODO: make this is a typesafe union.
3575	typedef llvm::SmallSetVector<DeclContext *, `16`> AssociatedNamespaceSet;
3576	typedef llvm::SmallSetVector<CXXRecordDecl *, `16`> AssociatedClassSet;
3577
3578	using ADLCallKind = CallExpr::ADLCallKind;
3579
3580	void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
3581	ArrayRef<Expr *> Args,
3582	OverloadCandidateSet &CandidateSet,
3583	bool SuppressUserConversions = false,
3584	bool PartialOverloading = false,
3585	bool AllowExplicit = true,
3586	bool AllowExplicitConversion = false,
3587	ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3588	ConversionSequenceList EarlyConversions = None,
3589	OverloadCandidateParamOrder PO = {});
3590	void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
3591	ArrayRef<Expr *> Args,
3592	OverloadCandidateSet &CandidateSet,
3593	TemplateArgumentListInfo ExplicitTemplateArgs = nullptr*,
3594	bool SuppressUserConversions = false,
3595	bool PartialOverloading = false,
3596	bool FirstArgumentIsBase = false);
3597	void AddMethodCandidate(DeclAccessPair FoundDecl,
3598	QualType ObjectType,
3599	Expr::Classification ObjectClassification,
3600	ArrayRef<Expr *> Args,
3601	OverloadCandidateSet& CandidateSet,
3602	bool SuppressUserConversion = false,
3603	OverloadCandidateParamOrder PO = {});
3604	void AddMethodCandidate(CXXMethodDecl *Method,
3605	DeclAccessPair FoundDecl,
3606	CXXRecordDecl *ActingContext, QualType ObjectType,
3607	Expr::Classification ObjectClassification,
3608	ArrayRef<Expr *> Args,
3609	OverloadCandidateSet& CandidateSet,
3610	bool SuppressUserConversions = false,
3611	bool PartialOverloading = false,
3612	ConversionSequenceList EarlyConversions = None,
3613	OverloadCandidateParamOrder PO = {});
3614	void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
3615	DeclAccessPair FoundDecl,
3616	CXXRecordDecl *ActingContext,
3617	TemplateArgumentListInfo *ExplicitTemplateArgs,
3618	QualType ObjectType,
3619	Expr::Classification ObjectClassification,
3620	ArrayRef<Expr *> Args,
3621	OverloadCandidateSet& CandidateSet,
3622	bool SuppressUserConversions = false,
3623	bool PartialOverloading = false,
3624	OverloadCandidateParamOrder PO = {});
3625	void AddTemplateOverloadCandidate(
3626	FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3627	TemplateArgumentListInfo ExplicitTemplateArgs, ArrayRef<Expr > Args,
3628	OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,
3629	bool PartialOverloading = false, bool AllowExplicit = true,
3630	ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3631	OverloadCandidateParamOrder PO = {});
3632	bool CheckNonDependentConversions(
3633	FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
3634	ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
3635	ConversionSequenceList &Conversions, bool SuppressUserConversions,
3636	CXXRecordDecl ActingContext = nullptr*, QualType ObjectType = QualType (),
3637	Expr::Classification ObjectClassification = {},
3638	OverloadCandidateParamOrder PO = {});
3639	void AddConversionCandidate(
3640	CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
3641	CXXRecordDecl ActingContext, Expr From, QualType ToType,
3642	OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3643	bool AllowExplicit, bool AllowResultConversion = true);
3644	void AddTemplateConversionCandidate(
3645	FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3646	CXXRecordDecl ActingContext, Expr From, QualType ToType,
3647	OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3648	bool AllowExplicit, bool AllowResultConversion = true);
3649	void AddSurrogateCandidate(CXXConversionDecl *Conversion,
3650	DeclAccessPair FoundDecl,
3651	CXXRecordDecl *ActingContext,
3652	const FunctionProtoType *Proto,
3653	Expr Object, ArrayRef<Expr > Args,
3654	OverloadCandidateSet& CandidateSet);
3655	void AddNonMemberOperatorCandidates(
3656	const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,
3657	OverloadCandidateSet &CandidateSet,
3658	TemplateArgumentListInfo ExplicitTemplateArgs = nullptr*);
3659	void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
3660	SourceLocation OpLoc, ArrayRef<Expr *> Args,
3661	OverloadCandidateSet &CandidateSet,
3662	OverloadCandidateParamOrder PO = {});
3663	void AddBuiltinCandidate(QualType ParamTys, ArrayRef<Expr > Args,
3664	OverloadCandidateSet& CandidateSet,
3665	bool IsAssignmentOperator = false,
3666	unsigned NumContextualBoolArguments = `0`);
3667	void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
3668	SourceLocation OpLoc, ArrayRef<Expr *> Args,
3669	OverloadCandidateSet& CandidateSet);
3670	void AddArgumentDependentLookupCandidates(DeclarationName Name,
3671	SourceLocation Loc,
3672	ArrayRef<Expr *> Args,
3673	TemplateArgumentListInfo *ExplicitTemplateArgs,
3674	OverloadCandidateSet& CandidateSet,
3675	bool PartialOverloading = false);
3676
3677	// Emit as a 'note' the specific overload candidate
3678	void NoteOverloadCandidate(
3679	NamedDecl Found, FunctionDecl Fn,
3680	OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(),
3681	QualType DestType = QualType (), bool TakingAddress = false);
3682
3683	// Emit as a series of 'note's all template and non-templates identified by
3684	// the expression Expr
3685	void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType (),
3686	bool TakingAddress = false);
3687
3688	/// Check the enable_if expressions on the given function. Returns the first
3689	/// failing attribute, or NULL if they were all successful.
3690	EnableIfAttr CheckEnableIf(FunctionDecl Function, SourceLocation CallLoc,
3691	ArrayRef<Expr *> Args,
3692	bool MissingImplicitThis = false);
3693
3694	/// Find the failed Boolean condition within a given Boolean
3695	/// constant expression, and describe it with a string.
3696	std::pair<Expr , std::string> findFailedBooleanCondition(Expr Cond);
3697
3698	/// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3699	/// non-ArgDependent DiagnoseIfAttrs.
3700	///
3701	/// Argument-dependent diagnose_if attributes should be checked each time a
3702	/// function is used as a direct callee of a function call.
3703	///
3704	/// Returns true if any errors were emitted.
3705	bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
3706	const Expr *ThisArg,
3707	ArrayRef<const Expr *> Args,
3708	SourceLocation Loc);
3709
3710	/// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3711	/// ArgDependent DiagnoseIfAttrs.
3712	///
3713	/// Argument-independent diagnose_if attributes should be checked on every use
3714	/// of a function.
3715	///
3716	/// Returns true if any errors were emitted.
3717	bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
3718	SourceLocation Loc);
3719
3720	/// Returns whether the given function's address can be taken or not,
3721	/// optionally emitting a diagnostic if the address can't be taken.
3722	///
3723	/// Returns false if taking the address of the function is illegal.
3724	bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
3725	bool Complain = false,
3726	SourceLocation Loc = SourceLocation ());
3727
3728	// [PossiblyAFunctionType] --> [Return]
3729	// NonFunctionType --> NonFunctionType
3730	// R (A) --> R(A)
3731	// R ()(A) --> R (A)*
3732	// R (&)(A) --> R (A)
3733	// R (S::)(A) --> R (A)*
3734	QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);
3735
3736	FunctionDecl *
3737	ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
3738	QualType TargetType,
3739	bool Complain,
3740	DeclAccessPair &Found,
3741	bool pHadMultipleCandidates = nullptr*);
3742
3743	FunctionDecl *
3744	resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult);
3745
3746	bool resolveAndFixAddressOfSingleOverloadCandidate(
3747	ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
3748
3749	FunctionDecl *
3750	ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
3751	bool Complain = false,
3752	DeclAccessPair Found = nullptr*);
3753
3754	bool ResolveAndFixSingleFunctionTemplateSpecialization(
3755	ExprResult &SrcExpr,
3756	bool DoFunctionPointerConverion = false,
3757	bool Complain = false,
3758	SourceRange OpRangeForComplaining = SourceRange (),
3759	QualType DestTypeForComplaining = QualType (),
3760	unsigned DiagIDForComplaining = `0`);
3761
3762
3763	Expr FixOverloadedFunctionReference(Expr E,
3764	DeclAccessPair FoundDecl,
3765	FunctionDecl *Fn);
3766	ExprResult FixOverloadedFunctionReference(ExprResult,
3767	DeclAccessPair FoundDecl,
3768	FunctionDecl *Fn);
3769
3770	void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
3771	ArrayRef<Expr *> Args,
3772	OverloadCandidateSet &CandidateSet,
3773	bool PartialOverloading = false);
3774	void AddOverloadedCallCandidates(
3775	LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
3776	ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet);
3777
3778	// An enum used to represent the different possible results of building a
3779	// range-based for loop.
3780	enum ForRangeStatus {
3781	FRS_Success,
3782	FRS_NoViableFunction,
3783	FRS_DiagnosticIssued
3784	};
3785
3786	ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,
3787	SourceLocation RangeLoc,
3788	const DeclarationNameInfo &NameInfo,
3789	LookupResult &MemberLookup,
3790	OverloadCandidateSet *CandidateSet,
3791	Expr Range, ExprResult CallExpr);
3792
3793	ExprResult BuildOverloadedCallExpr(Scope S, Expr Fn,
3794	UnresolvedLookupExpr *ULE,
3795	SourceLocation LParenLoc,
3796	MultiExprArg Args,
3797	SourceLocation RParenLoc,
3798	Expr *ExecConfig,
3799	bool AllowTypoCorrection=true,
3800	bool CalleesAddressIsTaken=false);
3801
3802	bool buildOverloadedCallSet(Scope S, Expr Fn, UnresolvedLookupExpr *ULE,
3803	MultiExprArg Args, SourceLocation RParenLoc,
3804	OverloadCandidateSet *CandidateSet,
3805	ExprResult *Result);
3806
3807	ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,
3808	NestedNameSpecifierLoc NNSLoc,
3809	DeclarationNameInfo DNI,
3810	const UnresolvedSetImpl &Fns,
3811	bool PerformADL = true);
3812
3813	ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
3814	UnaryOperatorKind Opc,
3815	const UnresolvedSetImpl &Fns,
3816	Expr input, bool* RequiresADL = true);
3817
3818	void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
3819	OverloadedOperatorKind Op,
3820	const UnresolvedSetImpl &Fns,
3821	ArrayRef<Expr > Args, bool* RequiresADL = true);
3822	ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
3823	BinaryOperatorKind Opc,
3824	const UnresolvedSetImpl &Fns,
3825	Expr LHS, Expr RHS,
3826	bool RequiresADL = true,
3827	bool AllowRewrittenCandidates = true,
3828	FunctionDecl DefaultedFn = nullptr*);
3829	ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc,
3830	const UnresolvedSetImpl &Fns,
3831	Expr LHS, Expr RHS,
3832	FunctionDecl *DefaultedFn);
3833
3834	ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
3835	SourceLocation RLoc,
3836	Expr Base,Expr Idx);
3837
3838	ExprResult BuildCallToMemberFunction(Scope S, Expr MemExpr,
3839	SourceLocation LParenLoc,
3840	MultiExprArg Args,
3841	SourceLocation RParenLoc,
3842	bool AllowRecovery = false);
3843	ExprResult
3844	BuildCallToObjectOfClassType(Scope S, Expr Object, SourceLocation LParenLoc,
3845	MultiExprArg Args,
3846	SourceLocation RParenLoc);
3847
3848	ExprResult BuildOverloadedArrowExpr(Scope S, Expr Base,
3849	SourceLocation OpLoc,
3850	bool NoArrowOperatorFound = nullptr*);
3851
3852	/// CheckCallReturnType - Checks that a call expression's return type is
3853	/// complete. Returns true on failure. The location passed in is the location
3854	/// that best represents the call.
3855	bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
3856	CallExpr CE, FunctionDecl FD);
3857
3858	/// Helpers for dealing with blocks and functions.
3859	bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
3860	bool CheckParameterNames);
3861	void CheckCXXDefaultArguments(FunctionDecl *FD);
3862	void CheckExtraCXXDefaultArguments(Declarator &D);
3863	Scope getNonFieldDeclScope(Scope S);
3864
3865	/// \name Name lookup
3866	///
3867	/// These routines provide name lookup that is used during semantic
3868	/// analysis to resolve the various kinds of names (identifiers,
3869	/// overloaded operator names, constructor names, etc.) into zero or
3870	/// more declarations within a particular scope. The major entry
3871	/// points are LookupName, which performs unqualified name lookup,
3872	/// and LookupQualifiedName, which performs qualified name lookup.
3873	///
3874	/// All name lookup is performed based on some specific criteria,
3875	/// which specify what names will be visible to name lookup and how
3876	/// far name lookup should work. These criteria are important both
3877	/// for capturing language semantics (certain lookups will ignore
3878	/// certain names, for example) and for performance, since name
3879	/// lookup is often a bottleneck in the compilation of C++. Name
3880	/// lookup criteria is specified via the LookupCriteria enumeration.
3881	///
3882	/// The results of name lookup can vary based on the kind of name
3883	/// lookup performed, the current language, and the translation
3884	/// unit. In C, for example, name lookup will either return nothing
3885	/// (no entity found) or a single declaration. In C++, name lookup
3886	/// can additionally refer to a set of overloaded functions or
3887	/// result in an ambiguity. All of the possible results of name
3888	/// lookup are captured by the LookupResult class, which provides
3889	/// the ability to distinguish among them.
3890	//@{
3891
3892	/// Describes the kind of name lookup to perform.
3893	enum LookupNameKind {
3894	/// Ordinary name lookup, which finds ordinary names (functions,
3895	/// variables, typedefs, etc.) in C and most kinds of names
3896	/// (functions, variables, members, types, etc.) in C++.
3897	LookupOrdinaryName = `0`,
3898	/// Tag name lookup, which finds the names of enums, classes,
3899	/// structs, and unions.
3900	LookupTagName,
3901	/// Label name lookup.
3902	LookupLabel,
3903	/// Member name lookup, which finds the names of
3904	/// class/struct/union members.
3905	LookupMemberName,
3906	/// Look up of an operator name (e.g., operator+) for use with
3907	/// operator overloading. This lookup is similar to ordinary name
3908	/// lookup, but will ignore any declarations that are class members.
3909	LookupOperatorName,
3910	/// Look up a name following ~ in a destructor name. This is an ordinary
3911	/// lookup, but prefers tags to typedefs.
3912	LookupDestructorName,
3913	/// Look up of a name that precedes the '::' scope resolution
3914	/// operator in C++. This lookup completely ignores operator, object,
3915	/// function, and enumerator names (C++ [basic.lookup.qual]p1).
3916	LookupNestedNameSpecifierName,
3917	/// Look up a namespace name within a C++ using directive or
3918	/// namespace alias definition, ignoring non-namespace names (C++
3919	/// [basic.lookup.udir]p1).
3920	LookupNamespaceName,
3921	/// Look up all declarations in a scope with the given name,
3922	/// including resolved using declarations. This is appropriate
3923	/// for checking redeclarations for a using declaration.
3924	LookupUsingDeclName,
3925	/// Look up an ordinary name that is going to be redeclared as a
3926	/// name with linkage. This lookup ignores any declarations that
3927	/// are outside of the current scope unless they have linkage. See
3928	/// C99 6.2.2p4-5 and C++ [basic.link]p6.
3929	LookupRedeclarationWithLinkage,
3930	/// Look up a friend of a local class. This lookup does not look
3931	/// outside the innermost non-class scope. See C++11 [class.friend]p11.
3932	LookupLocalFriendName,
3933	/// Look up the name of an Objective-C protocol.
3934	LookupObjCProtocolName,
3935	/// Look up implicit 'self' parameter of an objective-c method.
3936	LookupObjCImplicitSelfParam,
3937	/// Look up the name of an OpenMP user-defined reduction operation.
3938	LookupOMPReductionName,
3939	/// Look up the name of an OpenMP user-defined mapper.
3940	LookupOMPMapperName,
3941	/// Look up any declaration with any name.
3942	LookupAnyName
3943	};
3944
3945	/// Specifies whether (or how) name lookup is being performed for a
3946	/// redeclaration (vs. a reference).
3947	enum RedeclarationKind {
3948	/// The lookup is a reference to this name that is not for the
3949	/// purpose of redeclaring the name.
3950	NotForRedeclaration = `0`,
3951	/// The lookup results will be used for redeclaration of a name,
3952	/// if an entity by that name already exists and is visible.
3953	ForVisibleRedeclaration,
3954	/// The lookup results will be used for redeclaration of a name
3955	/// with external linkage; non-visible lookup results with external linkage
3956	/// may also be found.
3957	ForExternalRedeclaration
3958	};
3959
3960	RedeclarationKind forRedeclarationInCurContext() {
3961	// A declaration with an owning module for linkage can never link against
3962	// anything that is not visible. We don't need to check linkage here; if
3963	// the context has internal linkage, redeclaration lookup won't find things
3964	// from other TUs, and we can't safely compute linkage yet in general.
3965	if (cast<Decl>(CurContext)
3966	->getOwningModuleForLinkage(/IgnoreLinkage/true))
3967	return ForVisibleRedeclaration;
3968	return ForExternalRedeclaration;
3969	}
3970
3971	/// The possible outcomes of name lookup for a literal operator.
3972	enum LiteralOperatorLookupResult {
3973	/// The lookup resulted in an error.
3974	LOLR_Error,
3975	/// The lookup found no match but no diagnostic was issued.
3976	LOLR_ErrorNoDiagnostic,
3977	/// The lookup found a single 'cooked' literal operator, which
3978	/// expects a normal literal to be built and passed to it.
3979	LOLR_Cooked,
3980	/// The lookup found a single 'raw' literal operator, which expects
3981	/// a string literal containing the spelling of the literal token.
3982	LOLR_Raw,
3983	/// The lookup found an overload set of literal operator templates,
3984	/// which expect the characters of the spelling of the literal token to be
3985	/// passed as a non-type template argument pack.
3986	LOLR_Template,
3987	/// The lookup found an overload set of literal operator templates,
3988	/// which expect the character type and characters of the spelling of the
3989	/// string literal token to be passed as template arguments.
3990	LOLR_StringTemplatePack,
3991	};
3992
3993	SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,
3994	CXXSpecialMember SM,
3995	bool ConstArg,
3996	bool VolatileArg,
3997	bool RValueThis,
3998	bool ConstThis,
3999	bool VolatileThis);
4000
4001	typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator;
4002	typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)>
4003	TypoRecoveryCallback;
4004
4005	private:
4006	bool CppLookupName(LookupResult &R, Scope *S);
4007
4008	struct TypoExprState {
4009	std::unique_ptr<TypoCorrectionConsumer> Consumer;
4010	TypoDiagnosticGenerator DiagHandler;
4011	TypoRecoveryCallback RecoveryHandler;
4012	TypoExprState();
4013	TypoExprState(TypoExprState &&other) noexcept;
4014	TypoExprState &operator=(TypoExprState &&other) noexcept;
4015	};
4016
4017	/// The set of unhandled TypoExprs and their associated state.
4018	llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;
4019
4020	/// Creates a new TypoExpr AST node.
4021	TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
4022	TypoDiagnosticGenerator TDG,
4023	TypoRecoveryCallback TRC, SourceLocation TypoLoc);
4024
4025	// The set of known/encountered (unique, canonicalized) NamespaceDecls.
4026	//
4027	// The boolean value will be true to indicate that the namespace was loaded
4028	// from an AST/PCH file, or false otherwise.
4029	llvm::MapVector<NamespaceDecl, bool*> KnownNamespaces;
4030
4031	/// Whether we have already loaded known namespaces from an extenal
4032	/// source.
4033	bool LoadedExternalKnownNamespaces;
4034
4035	/// Helper for CorrectTypo and CorrectTypoDelayed used to create and
4036	/// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction
4037	/// should be skipped entirely.
4038	std::unique_ptr<TypoCorrectionConsumer>
4039	makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,
4040	Sema::LookupNameKind LookupKind, Scope *S,
4041	CXXScopeSpec *SS,
4042	CorrectionCandidateCallback &CCC,
4043	DeclContext MemberContext, bool* EnteringContext,
4044	const ObjCObjectPointerType *OPT,
4045	bool ErrorRecovery);
4046
4047	public:
4048	const TypoExprState &getTypoExprState(TypoExpr TE) const*;
4049
4050	/// Clears the state of the given TypoExpr.
4051	void clearDelayedTypo(TypoExpr *TE);
4052
4053	/// Look up a name, looking for a single declaration. Return
4054	/// null if the results were absent, ambiguous, or overloaded.
4055	///
4056	/// It is preferable to use the elaborated form and explicitly handle
4057	/// ambiguity and overloaded.
4058	NamedDecl LookupSingleName(Scope S, DeclarationName Name,
4059	SourceLocation Loc,
4060	LookupNameKind NameKind,
4061	RedeclarationKind Redecl
4062	= NotForRedeclaration);
4063	bool LookupBuiltin(LookupResult &R);
4064	void LookupNecessaryTypesForBuiltin(Scope S, unsigned* ID);
4065	bool LookupName(LookupResult &R, Scope *S,
4066	bool AllowBuiltinCreation = false);
4067	bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
4068	bool InUnqualifiedLookup = false);
4069	bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
4070	CXXScopeSpec &SS);
4071	bool LookupParsedName(LookupResult &R, Scope S, CXXScopeSpec SS,
4072	bool AllowBuiltinCreation = false,
4073	bool EnteringContext = false);
4074	ObjCProtocolDecl LookupProtocol(IdentifierInfo II, SourceLocation IdLoc,
4075	RedeclarationKind Redecl
4076	= NotForRedeclaration);
4077	bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);
4078
4079	void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
4080	UnresolvedSetImpl &Functions);
4081
4082	LabelDecl LookupOrCreateLabel(IdentifierInfo II, SourceLocation IdentLoc,
4083	SourceLocation GnuLabelLoc = SourceLocation ());
4084
4085	DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);
4086	CXXConstructorDecl LookupDefaultConstructor(CXXRecordDecl Class);
4087	CXXConstructorDecl LookupCopyingConstructor(CXXRecordDecl Class,
4088	unsigned Quals);
4089	CXXMethodDecl LookupCopyingAssignment(CXXRecordDecl Class, unsigned Quals,
4090	bool RValueThis, unsigned ThisQuals);
4091	CXXConstructorDecl LookupMovingConstructor(CXXRecordDecl Class,
4092	unsigned Quals);
4093	CXXMethodDecl LookupMovingAssignment(CXXRecordDecl Class, unsigned Quals,
4094	bool RValueThis, unsigned ThisQuals);
4095	CXXDestructorDecl LookupDestructor(CXXRecordDecl Class);
4096
4097	bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id);
4098	LiteralOperatorLookupResult
4099	LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys,
4100	bool AllowRaw, bool AllowTemplate,
4101	bool AllowStringTemplate, bool DiagnoseMissing,
4102	StringLiteral StringLit = nullptr*);
4103	bool isKnownName(StringRef name);
4104
4105	/// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
4106	enum class FunctionEmissionStatus {
4107	Emitted,
4108	CUDADiscarded, // Discarded due to CUDA/HIP hostness
4109	OMPDiscarded, // Discarded due to OpenMP hostness
4110	TemplateDiscarded, // Discarded due to uninstantiated templates
4111	Unknown,
4112	};
4113	FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl,
4114	bool Final = false);
4115
4116	// Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check.
4117	bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee);
4118
4119	void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
4120	ArrayRef<Expr *> Args, ADLResult &Functions);
4121
4122	void LookupVisibleDecls(Scope *S, LookupNameKind Kind,
4123	VisibleDeclConsumer &Consumer,
4124	bool IncludeGlobalScope = true,
4125	bool LoadExternal = true);
4126	void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
4127	VisibleDeclConsumer &Consumer,
4128	bool IncludeGlobalScope = true,
4129	bool IncludeDependentBases = false,
4130	bool LoadExternal = true);
4131
4132	enum CorrectTypoKind {
4133	CTK_NonError, // CorrectTypo used in a non error recovery situation.
4134	CTK_ErrorRecovery // CorrectTypo used in normal error recovery.
4135	};
4136
4137	TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
4138	Sema::LookupNameKind LookupKind,
4139	Scope S, CXXScopeSpec SS,
4140	CorrectionCandidateCallback &CCC,
4141	CorrectTypoKind Mode,
4142	DeclContext MemberContext = nullptr*,
4143	bool EnteringContext = false,
4144	const ObjCObjectPointerType OPT = nullptr*,
4145	bool RecordFailure = true);
4146
4147	TypoExpr CorrectTypoDelayed(const* DeclarationNameInfo &Typo,
4148	Sema::LookupNameKind LookupKind, Scope *S,
4149	CXXScopeSpec *SS,
4150	CorrectionCandidateCallback &CCC,
4151	TypoDiagnosticGenerator TDG,
4152	TypoRecoveryCallback TRC, CorrectTypoKind Mode,
4153	DeclContext MemberContext = nullptr*,
4154	bool EnteringContext = false,
4155	const ObjCObjectPointerType OPT = nullptr*);
4156
4157	/// Process any TypoExprs in the given Expr and its children,
4158	/// generating diagnostics as appropriate and returning a new Expr if there
4159	/// were typos that were all successfully corrected and ExprError if one or
4160	/// more typos could not be corrected.
4161	///
4162	/// \param E The Expr to check for TypoExprs.
4163	///
4164	/// \param InitDecl A VarDecl to avoid because the Expr being corrected is its
4165	/// initializer.
4166	///
4167	/// \param RecoverUncorrectedTypos If true, when typo correction fails, it
4168	/// will rebuild the given Expr with all TypoExprs degraded to RecoveryExprs.
4169	///
4170	/// \param Filter A function applied to a newly rebuilt Expr to determine if
4171	/// it is an acceptable/usable result from a single combination of typo
4172	/// corrections. As long as the filter returns ExprError, different
4173	/// combinations of corrections will be tried until all are exhausted.
4174	ExprResult CorrectDelayedTyposInExpr(
4175	Expr E, VarDecl InitDecl = nullptr,
4176	bool RecoverUncorrectedTypos = false,
4177	llvm::function_ref<ExprResult(Expr *)> Filter =
4178	[](Expr E) -> ExprResult { return* E; });
4179
4180	ExprResult CorrectDelayedTyposInExpr(
4181	ExprResult ER, VarDecl InitDecl = nullptr*,
4182	bool RecoverUncorrectedTypos = false,
4183	llvm::function_ref<ExprResult(Expr *)> Filter =
4184	[](Expr E) -> ExprResult { return* E; }) {
4185	return ER.isInvalid()
4186	? ER
4187	: CorrectDelayedTyposInExpr(ER.get(), InitDecl,
4188	RecoverUncorrectedTypos, Filter);
4189	}
4190
4191	void diagnoseTypo(const TypoCorrection &Correction,
4192	const PartialDiagnostic &TypoDiag,
4193	bool ErrorRecovery = true);
4194
4195	void diagnoseTypo(const TypoCorrection &Correction,
4196	const PartialDiagnostic &TypoDiag,
4197	const PartialDiagnostic &PrevNote,
4198	bool ErrorRecovery = true);
4199
4200	void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);
4201
4202	void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,
4203	ArrayRef<Expr *> Args,
4204	AssociatedNamespaceSet &AssociatedNamespaces,
4205	AssociatedClassSet &AssociatedClasses);
4206
4207	void FilterLookupForScope(LookupResult &R, DeclContext Ctx, Scope S,
4208	bool ConsiderLinkage, bool AllowInlineNamespace);
4209
4210	bool CheckRedeclarationModuleOwnership(NamedDecl New, NamedDecl Old);
4211
4212	void DiagnoseAmbiguousLookup(LookupResult &Result);
4213	//@}
4214
4215	/// Attempts to produce a RecoveryExpr after some AST node cannot be created.
4216	ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,
4217	ArrayRef<Expr *> SubExprs,
4218	QualType T = QualType ());
4219
4220	ObjCInterfaceDecl getObjCInterfaceDecl(IdentifierInfo &Id,
4221	SourceLocation IdLoc,
4222	bool TypoCorrection = false);
4223	FunctionDecl CreateBuiltin(IdentifierInfo II, QualType Type, unsigned ID,
4224	SourceLocation Loc);
4225	NamedDecl LazilyCreateBuiltin(IdentifierInfo II, unsigned ID,
4226	Scope S, bool* ForRedeclaration,
4227	SourceLocation Loc);
4228	NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
4229	Scope *S);
4230	void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(
4231	FunctionDecl *FD);
4232	void AddKnownFunctionAttributes(FunctionDecl *FD);
4233
4234	// More parsing and symbol table subroutines.
4235
4236	void ProcessPragmaWeak(Scope S, Decl D);
4237	// Decl attributes - this routine is the top level dispatcher.
4238	void ProcessDeclAttributes(Scope S, Decl D, const Declarator &PD);
4239	// Helper for delayed processing of attributes.
4240	void ProcessDeclAttributeDelayed(Decl *D,
4241	const ParsedAttributesView &AttrList);
4242	void ProcessDeclAttributeList(Scope S, Decl D, const ParsedAttributesView &AL,
4243	bool IncludeCXX11Attributes = true);
4244	bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
4245	const ParsedAttributesView &AttrList);
4246
4247	void checkUnusedDeclAttributes(Declarator &D);
4248
4249	/// Determine if type T is a valid subject for a nonnull and similar
4250	/// attributes. By default, we look through references (the behavior used by
4251	/// nonnull), but if the second parameter is true, then we treat a reference
4252	/// type as valid.
4253	bool isValidPointerAttrType(QualType T, bool RefOkay = false);
4254
4255	bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value);
4256	bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC,
4257	const FunctionDecl FD = nullptr*);
4258	bool CheckAttrTarget(const ParsedAttr &CurrAttr);
4259	bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);
4260	bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum,
4261	StringRef &Str,
4262	SourceLocation ArgLocation = nullptr*);
4263	bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
4264	bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
4265	bool checkMSInheritanceAttrOnDefinition(
4266	CXXRecordDecl RD, SourceRange Range, bool* BestCase,
4267	MSInheritanceModel SemanticSpelling);
4268
4269	void CheckAlignasUnderalignment(Decl *D);
4270
4271	/// Adjust the calling convention of a method to be the ABI default if it
4272	/// wasn't specified explicitly. This handles method types formed from
4273	/// function type typedefs and typename template arguments.
4274	void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
4275	SourceLocation Loc);
4276
4277	// Check if there is an explicit attribute, but only look through parens.
4278	// The intent is to look for an attribute on the current declarator, but not
4279	// one that came from a typedef.
4280	bool hasExplicitCallingConv(QualType T);
4281
4282	/// Get the outermost AttributedType node that sets a calling convention.
4283	/// Valid types should not have multiple attributes with different CCs.
4284	const AttributedType getCallingConvAttributedType(QualType T) const*;
4285
4286	/// Stmt attributes - this routine is the top level dispatcher.
4287	StmtResult ProcessStmtAttributes(Stmt *Stmt,
4288	const ParsedAttributesView &Attrs,
4289	SourceRange Range);
4290
4291	void WarnConflictingTypedMethods(ObjCMethodDecl *Method,
4292	ObjCMethodDecl *MethodDecl,
4293	bool IsProtocolMethodDecl);
4294
4295	void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
4296	ObjCMethodDecl *Overridden,
4297	bool IsProtocolMethodDecl);
4298
4299	/// WarnExactTypedMethods - This routine issues a warning if method
4300	/// implementation declaration matches exactly that of its declaration.
4301	void WarnExactTypedMethods(ObjCMethodDecl *Method,
4302	ObjCMethodDecl *MethodDecl,
4303	bool IsProtocolMethodDecl);
4304
4305	typedef llvm::SmallPtrSet<Selector, `8`> SelectorSet;
4306
4307	/// CheckImplementationIvars - This routine checks if the instance variables
4308	/// listed in the implelementation match those listed in the interface.
4309	void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
4310	ObjCIvarDecl *Fields, unsigned* nIvars,
4311	SourceLocation Loc);
4312
4313	/// ImplMethodsVsClassMethods - This is main routine to warn if any method
4314	/// remains unimplemented in the class or category \@implementation.
4315	void ImplMethodsVsClassMethods(Scope S, ObjCImplDecl IMPDecl,
4316	ObjCContainerDecl* IDecl,
4317	bool IncompleteImpl = false);
4318
4319	/// DiagnoseUnimplementedProperties - This routine warns on those properties
4320	/// which must be implemented by this implementation.
4321	void DiagnoseUnimplementedProperties(Scope S, ObjCImplDecl IMPDecl,
4322	ObjCContainerDecl *CDecl,
4323	bool SynthesizeProperties);
4324
4325	/// Diagnose any null-resettable synthesized setters.
4326	void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl);
4327
4328	/// DefaultSynthesizeProperties - This routine default synthesizes all
4329	/// properties which must be synthesized in the class's \@implementation.
4330	void DefaultSynthesizeProperties(Scope S, ObjCImplDecl IMPDecl,
4331	ObjCInterfaceDecl *IDecl,
4332	SourceLocation AtEnd);
4333	void DefaultSynthesizeProperties(Scope S, Decl D, SourceLocation AtEnd);
4334
4335	/// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
4336	/// an ivar synthesized for 'Method' and 'Method' is a property accessor
4337	/// declared in class 'IFace'.
4338	bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
4339	ObjCMethodDecl Method, ObjCIvarDecl IV);
4340
4341	/// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which
4342	/// backs the property is not used in the property's accessor.
4343	void DiagnoseUnusedBackingIvarInAccessor(Scope *S,
4344	const ObjCImplementationDecl *ImplD);
4345
4346	/// GetIvarBackingPropertyAccessor - If method is a property setter/getter and
4347	/// it property has a backing ivar, returns this ivar; otherwise, returns NULL.
4348	/// It also returns ivar's property on success.
4349	ObjCIvarDecl GetIvarBackingPropertyAccessor(const* ObjCMethodDecl *Method,
4350	const ObjCPropertyDecl &PDecl) const*;
4351
4352	/// Called by ActOnProperty to handle \@property declarations in
4353	/// class extensions.
4354	ObjCPropertyDecl HandlePropertyInClassExtension(Scope S,
4355	SourceLocation AtLoc,
4356	SourceLocation LParenLoc,
4357	FieldDeclarator &FD,
4358	Selector GetterSel,
4359	SourceLocation GetterNameLoc,
4360	Selector SetterSel,
4361	SourceLocation SetterNameLoc,
4362	const bool isReadWrite,
4363	unsigned &Attributes,
4364	const unsigned AttributesAsWritten,
4365	QualType T,
4366	TypeSourceInfo *TSI,
4367	tok::ObjCKeywordKind MethodImplKind);
4368
4369	/// Called by ActOnProperty and HandlePropertyInClassExtension to
4370	/// handle creating the ObjcPropertyDecl for a category or \@interface.
4371	ObjCPropertyDecl CreatePropertyDecl(Scope S,
4372	ObjCContainerDecl *CDecl,
4373	SourceLocation AtLoc,
4374	SourceLocation LParenLoc,
4375	FieldDeclarator &FD,
4376	Selector GetterSel,
4377	SourceLocation GetterNameLoc,
4378	Selector SetterSel,
4379	SourceLocation SetterNameLoc,
4380	const bool isReadWrite,
4381	const unsigned Attributes,
4382	const unsigned AttributesAsWritten,
4383	QualType T,
4384	TypeSourceInfo *TSI,
4385	tok::ObjCKeywordKind MethodImplKind,
4386	DeclContext lexicalDC = nullptr*);
4387
4388	/// AtomicPropertySetterGetterRules - This routine enforces the rule (via
4389	/// warning) when atomic property has one but not the other user-declared
4390	/// setter or getter.
4391	void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
4392	ObjCInterfaceDecl* IDecl);
4393
4394	void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);
4395
4396	void DiagnoseMissingDesignatedInitOverrides(
4397	const ObjCImplementationDecl *ImplD,
4398	const ObjCInterfaceDecl *IFD);
4399
4400	void DiagnoseDuplicateIvars(ObjCInterfaceDecl ID, ObjCInterfaceDecl SID);
4401
4402	enum MethodMatchStrategy {
4403	MMS_loose,
4404	MMS_strict
4405	};
4406
4407	/// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
4408	/// true, or false, accordingly.
4409	bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
4410	const ObjCMethodDecl *PrevMethod,
4411	MethodMatchStrategy strategy = MMS_strict);
4412
4413	/// MatchAllMethodDeclarations - Check methods declaraed in interface or
4414	/// or protocol against those declared in their implementations.
4415	void MatchAllMethodDeclarations(const SelectorSet &InsMap,
4416	const SelectorSet &ClsMap,
4417	SelectorSet &InsMapSeen,
4418	SelectorSet &ClsMapSeen,
4419	ObjCImplDecl* IMPDecl,
4420	ObjCContainerDecl* IDecl,
4421	bool &IncompleteImpl,
4422	bool ImmediateClass,
4423	bool WarnCategoryMethodImpl=false);
4424
4425	/// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
4426	/// category matches with those implemented in its primary class and
4427	/// warns each time an exact match is found.
4428	void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);
4429
4430	/// Add the given method to the list of globally-known methods.
4431	void addMethodToGlobalList(ObjCMethodList List, ObjCMethodDecl Method);
4432
4433	/// Returns default addr space for method qualifiers.
4434	LangAS getDefaultCXXMethodAddrSpace() const;
4435
4436	private:
4437	/// AddMethodToGlobalPool - Add an instance or factory method to the global
4438	/// pool. See descriptoin of AddInstanceMethodToGlobalPool.
4439	void AddMethodToGlobalPool(ObjCMethodDecl Method, bool* impl, bool instance);
4440
4441	/// LookupMethodInGlobalPool - Returns the instance or factory method and
4442	/// optionally warns if there are multiple signatures.
4443	ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,
4444	bool receiverIdOrClass,
4445	bool instance);
4446
4447	public:
4448	/// - Returns instance or factory methods in global method pool for
4449	/// given selector. It checks the desired kind first, if none is found, and
4450	/// parameter checkTheOther is set, it then checks the other kind. If no such
4451	/// method or only one method is found, function returns false; otherwise, it
4452	/// returns true.
4453	bool
4454	CollectMultipleMethodsInGlobalPool(Selector Sel,
4455	SmallVectorImpl<ObjCMethodDecl*>& Methods,
4456	bool InstanceFirst, bool CheckTheOther,
4457	const ObjCObjectType TypeBound = nullptr*);
4458
4459	bool
4460	AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod,
4461	SourceRange R, bool receiverIdOrClass,
4462	SmallVectorImpl<ObjCMethodDecl*>& Methods);
4463
4464	void
4465	DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods,
4466	Selector Sel, SourceRange R,
4467	bool receiverIdOrClass);
4468
4469	private:
4470	/// - Returns a selector which best matches given argument list or
4471	/// nullptr if none could be found
4472	ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args,
4473	bool IsInstance,
4474	SmallVectorImpl<ObjCMethodDecl*>& Methods);
4475
4476
4477	/// Record the typo correction failure and return an empty correction.
4478	TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc,
4479	bool RecordFailure = true) {
4480	if (RecordFailure)
4481	TypoCorrectionFailures [Typo].insert(TypoLoc);
4482	return TypoCorrection ();
4483	}
4484
4485	public:
4486	/// AddInstanceMethodToGlobalPool - All instance methods in a translation
4487	/// unit are added to a global pool. This allows us to efficiently associate
4488	/// a selector with a method declaraation for purposes of typechecking
4489	/// messages sent to "id" (where the class of the object is unknown).
4490	void AddInstanceMethodToGlobalPool(ObjCMethodDecl Method, bool* impl=false) {
4491	AddMethodToGlobalPool(Method, impl, /instance/true);
4492	}
4493
4494	/// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
4495	void AddFactoryMethodToGlobalPool(ObjCMethodDecl Method, bool* impl=false) {
4496	AddMethodToGlobalPool(Method, impl, /instance/false);
4497	}
4498
4499	/// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
4500	/// pool.
4501	void AddAnyMethodToGlobalPool(Decl *D);
4502
4503	/// LookupInstanceMethodInGlobalPool - Returns the method and warns if
4504	/// there are multiple signatures.
4505	ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
4506	bool receiverIdOrClass=false) {
4507	return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
4508	/instance/true);
4509	}
4510
4511	/// LookupFactoryMethodInGlobalPool - Returns the method and warns if
4512	/// there are multiple signatures.
4513	ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R,
4514	bool receiverIdOrClass=false) {
4515	return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
4516	/instance/false);
4517	}
4518
4519	const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel,
4520	QualType ObjectType=QualType ());
4521	/// LookupImplementedMethodInGlobalPool - Returns the method which has an
4522	/// implementation.
4523	ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);
4524
4525	/// CollectIvarsToConstructOrDestruct - Collect those ivars which require
4526	/// initialization.
4527	void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
4528	SmallVectorImpl<ObjCIvarDecl*> &Ivars);
4529
4530	//===--------------------------------------------------------------------===//
4531	// Statement Parsing Callbacks: SemaStmt.cpp.
4532	public:
4533	class FullExprArg {
4534	public:
4535	FullExprArg() : E(nullptr) { }
4536	FullExprArg(Sema &actions) : E(nullptr) { }
4537
4538	ExprResult release() {
4539	return E;
4540	}
4541
4542	Expr get() const* { return E; }
4543
4544	Expr *operator->() {
4545	return E;
4546	}
4547
4548	private:
4549	// FIXME: No need to make the entire Sema class a friend when it's just
4550	// Sema::MakeFullExpr that needs access to the constructor below.
4551	friend class Sema;
4552
4553	explicit FullExprArg(Expr *expr) : E(expr) {}
4554
4555	Expr *E;
4556	};
4557
4558	FullExprArg MakeFullExpr(Expr *Arg) {
4559	return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation ());
4560	}
4561	FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {
4562	return FullExprArg (
4563	ActOnFinishFullExpr(Arg, CC, /DiscardedValue/ false).get());
4564	}
4565	FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) {
4566	ExprResult FE =
4567	ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation (),
4568	/DiscardedValue/ true);
4569	return FullExprArg (FE.get());
4570	}
4571
4572	StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue = true);
4573	StmtResult ActOnExprStmtError();
4574
4575	StmtResult ActOnNullStmt(SourceLocation SemiLoc,
4576	bool HasLeadingEmptyMacro = false);
4577
4578	void ActOnStartOfCompoundStmt(bool IsStmtExpr);
4579	void ActOnAfterCompoundStatementLeadingPragmas();
4580	void ActOnFinishOfCompoundStmt();
4581	StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
4582	ArrayRef<Stmt > Elts, bool* isStmtExpr);
4583
4584	/// A RAII object to enter scope of a compound statement.
4585	class CompoundScopeRAII {
4586	public:
4587	CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) {
4588	S.ActOnStartOfCompoundStmt(IsStmtExpr);
4589	}
4590
4591	~CompoundScopeRAII() {
4592	S.ActOnFinishOfCompoundStmt();
4593	}
4594
4595	private:
4596	Sema &S;
4597	};
4598
4599	/// An RAII helper that pops function a function scope on exit.
4600	struct FunctionScopeRAII {
4601	Sema &S;
4602	bool Active;
4603	FunctionScopeRAII(Sema &S) : S(S), Active(true) {}
4604	~FunctionScopeRAII() {
4605	if (Active)
4606	S.PopFunctionScopeInfo();
4607	}
4608	void disable() { Active = false; }
4609	};
4610
4611	StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
4612	SourceLocation StartLoc,
4613	SourceLocation EndLoc);
4614	void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
4615	StmtResult ActOnForEachLValueExpr(Expr *E);
4616	ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val);
4617	StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS,
4618	SourceLocation DotDotDotLoc, ExprResult RHS,
4619	SourceLocation ColonLoc);
4620	void ActOnCaseStmtBody(Stmt CaseStmt, Stmt SubStmt);
4621
4622	StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
4623	SourceLocation ColonLoc,
4624	Stmt SubStmt, Scope CurScope);
4625	StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
4626	SourceLocation ColonLoc, Stmt *SubStmt);
4627
4628	StmtResult ActOnAttributedStmt(SourceLocation AttrLoc,
4629	ArrayRef<const Attr*> Attrs,
4630	Stmt *SubStmt);
4631
4632	class ConditionResult;
4633	StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
4634	SourceLocation LParenLoc, Stmt *InitStmt,
4635	ConditionResult Cond, SourceLocation RParenLoc,
4636	Stmt ThenVal, SourceLocation ElseLoc, Stmt ElseVal);
4637	StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
4638	SourceLocation LParenLoc, Stmt *InitStmt,
4639	ConditionResult Cond, SourceLocation RParenLoc,
4640	Stmt ThenVal, SourceLocation ElseLoc, Stmt ElseVal);
4641	StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
4642	SourceLocation LParenLoc, Stmt *InitStmt,
4643	ConditionResult Cond,
4644	SourceLocation RParenLoc);
4645	StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
4646	Stmt Switch, Stmt Body);
4647	StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
4648	ConditionResult Cond, SourceLocation RParenLoc,
4649	Stmt *Body);
4650	StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
4651	SourceLocation WhileLoc, SourceLocation CondLParen,
4652	Expr *Cond, SourceLocation CondRParen);
4653
4654	StmtResult ActOnForStmt(SourceLocation ForLoc,
4655	SourceLocation LParenLoc,
4656	Stmt *First,
4657	ConditionResult Second,
4658	FullExprArg Third,
4659	SourceLocation RParenLoc,
4660	Stmt *Body);
4661	ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,
4662	Expr *collection);
4663	StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
4664	Stmt First, Expr collection,
4665	SourceLocation RParenLoc);
4666	StmtResult FinishObjCForCollectionStmt(Stmt ForCollection, Stmt Body);
4667
4668	enum BuildForRangeKind {
4669	/// Initial building of a for-range statement.
4670	BFRK_Build,
4671	/// Instantiation or recovery rebuild of a for-range statement. Don't
4672	/// attempt any typo-correction.
4673	BFRK_Rebuild,
4674	/// Determining whether a for-range statement could be built. Avoid any
4675	/// unnecessary or irreversible actions.
4676	BFRK_Check
4677	};
4678
4679	StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,
4680	SourceLocation CoawaitLoc,
4681	Stmt *InitStmt,
4682	Stmt *LoopVar,
4683	SourceLocation ColonLoc, Expr *Collection,
4684	SourceLocation RParenLoc,
4685	BuildForRangeKind Kind);
4686	StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
4687	SourceLocation CoawaitLoc,
4688	Stmt *InitStmt,
4689	SourceLocation ColonLoc,
4690	Stmt RangeDecl, Stmt Begin, Stmt *End,
4691	Expr Cond, Expr Inc,
4692	Stmt *LoopVarDecl,
4693	SourceLocation RParenLoc,
4694	BuildForRangeKind Kind);
4695	StmtResult FinishCXXForRangeStmt(Stmt ForRange, Stmt Body);
4696
4697	StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
4698	SourceLocation LabelLoc,
4699	LabelDecl *TheDecl);
4700	StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
4701	SourceLocation StarLoc,
4702	Expr *DestExp);
4703	StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
4704	StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
4705
4706	void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
4707	CapturedRegionKind Kind, unsigned NumParams);
4708	typedef std::pair<StringRef, QualType> CapturedParamNameType;
4709	void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
4710	CapturedRegionKind Kind,
4711	ArrayRef<CapturedParamNameType> Params,
4712	unsigned OpenMPCaptureLevel = `0`);
4713	StmtResult ActOnCapturedRegionEnd(Stmt *S);
4714	void ActOnCapturedRegionError();
4715	RecordDecl CreateCapturedStmtRecordDecl(CapturedDecl &CD,
4716	SourceLocation Loc,
4717	unsigned NumParams);
4718
4719	enum CopyElisionSemanticsKind {
4720	CES_Strict = `0`,
4721	CES_AllowParameters = `1`,
4722	CES_AllowDifferentTypes = `2`,
4723	CES_AllowExceptionVariables = `4`,
4724	CES_FormerDefault = (CES_AllowParameters),
4725	CES_Default = (CES_AllowParameters \| CES_AllowDifferentTypes),
4726	CES_AsIfByStdMove = (CES_AllowParameters \| CES_AllowDifferentTypes \|
4727	CES_AllowExceptionVariables),
4728	};
4729
4730	VarDecl getCopyElisionCandidate(QualType ReturnType, Expr E,
4731	CopyElisionSemanticsKind CESK);
4732	bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,
4733	CopyElisionSemanticsKind CESK);
4734
4735	StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
4736	Scope *CurScope);
4737	StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
4738	StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
4739
4740	StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
4741	bool IsVolatile, unsigned NumOutputs,
4742	unsigned NumInputs, IdentifierInfo **Names,
4743	MultiExprArg Constraints, MultiExprArg Exprs,
4744	Expr *AsmString, MultiExprArg Clobbers,
4745	unsigned NumLabels,
4746	SourceLocation RParenLoc);
4747
4748	void FillInlineAsmIdentifierInfo(Expr *Res,
4749	llvm::InlineAsmIdentifierInfo &Info);
4750	ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,
4751	SourceLocation TemplateKWLoc,
4752	UnqualifiedId &Id,
4753	bool IsUnevaluatedContext);
4754	bool LookupInlineAsmField(StringRef Base, StringRef Member,
4755	unsigned &Offset, SourceLocation AsmLoc);
4756	ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,
4757	SourceLocation AsmLoc);
4758	StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
4759	ArrayRef<Token> AsmToks,
4760	StringRef AsmString,
4761	unsigned NumOutputs, unsigned NumInputs,
4762	ArrayRef<StringRef> Constraints,
4763	ArrayRef<StringRef> Clobbers,
4764	ArrayRef<Expr*> Exprs,
4765	SourceLocation EndLoc);
4766	LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
4767	SourceLocation Location,
4768	bool AlwaysCreate);
4769
4770	VarDecl BuildObjCExceptionDecl(TypeSourceInfo TInfo, QualType ExceptionType,
4771	SourceLocation StartLoc,
4772	SourceLocation IdLoc, IdentifierInfo *Id,
4773	bool Invalid = false);
4774
4775	Decl ActOnObjCExceptionDecl(Scope S, Declarator &D);
4776
4777	StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,
4778	Decl Parm, Stmt Body);
4779
4780	StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);
4781
4782	StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
4783	MultiStmtArg Catch, Stmt *Finally);
4784
4785	StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);
4786	StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
4787	Scope *CurScope);
4788	ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,
4789	Expr *operand);
4790	StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
4791	Expr *SynchExpr,
4792	Stmt *SynchBody);
4793
4794	StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);
4795
4796	VarDecl BuildExceptionDeclaration(Scope S, TypeSourceInfo *TInfo,
4797	SourceLocation StartLoc,
4798	SourceLocation IdLoc,
4799	IdentifierInfo *Id);
4800
4801	Decl ActOnExceptionDeclarator(Scope S, Declarator &D);
4802
4803	StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
4804	Decl ExDecl, Stmt HandlerBlock);
4805	StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
4806	ArrayRef<Stmt *> Handlers);
4807
4808	StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?
4809	SourceLocation TryLoc, Stmt *TryBlock,
4810	Stmt *Handler);
4811	StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
4812	Expr *FilterExpr,
4813	Stmt *Block);
4814	void ActOnStartSEHFinallyBlock();
4815	void ActOnAbortSEHFinallyBlock();
4816	StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
4817	StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);
4818
4819	void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
4820
4821	bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl D) const*;
4822
4823	/// If it's a file scoped decl that must warn if not used, keep track
4824	/// of it.
4825	void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
4826
4827	/// DiagnoseUnusedExprResult - If the statement passed in is an expression
4828	/// whose result is unused, warn.
4829	void DiagnoseUnusedExprResult(const Stmt *S);
4830	void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);
4831	void DiagnoseUnusedDecl(const NamedDecl *ND);
4832
4833	/// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
4834	/// statement as a \p Body, and it is located on the same line.
4835	///
4836	/// This helps prevent bugs due to typos, such as:
4837	/// if (condition);
4838	/// do_stuff();
4839	void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,
4840	const Stmt *Body,
4841	unsigned DiagID);
4842
4843	/// Warn if a for/while loop statement \p S, which is followed by
4844	/// \p PossibleBody, has a suspicious null statement as a body.
4845	void DiagnoseEmptyLoopBody(const Stmt *S,
4846	const Stmt *PossibleBody);
4847
4848	/// Warn if a value is moved to itself.
4849	void DiagnoseSelfMove(const Expr LHSExpr, const* Expr *RHSExpr,
4850	SourceLocation OpLoc);
4851
4852	/// Warn if we're implicitly casting from a _Nullable pointer type to a
4853	/// _Nonnull one.
4854	void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,
4855	SourceLocation Loc);
4856
4857	/// Warn when implicitly casting 0 to nullptr.
4858	void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);
4859
4860	ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {
4861	return DelayedDiagnostics.push(pool);
4862	}
4863	void PopParsingDeclaration(ParsingDeclState state, Decl *decl);
4864
4865	typedef ProcessingContextState ParsingClassState;
4866	ParsingClassState PushParsingClass() {
4867	ParsingClassDepth++;
4868	return DelayedDiagnostics.pushUndelayed();
4869	}
4870	void PopParsingClass(ParsingClassState state) {
4871	ParsingClassDepth--;
4872	DelayedDiagnostics.popUndelayed(state);
4873	}
4874
4875	void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);
4876
4877	void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
4878	const ObjCInterfaceDecl *UnknownObjCClass,
4879	bool ObjCPropertyAccess,
4880	bool AvoidPartialAvailabilityChecks = false,
4881	ObjCInterfaceDecl ClassReceiver = nullptr*);
4882
4883	bool makeUnavailableInSystemHeader(SourceLocation loc,
4884	UnavailableAttr::ImplicitReason reason);
4885
4886	/// Issue any -Wunguarded-availability warnings in \c FD
4887	void DiagnoseUnguardedAvailabilityViolations(Decl *FD);
4888
4889	void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
4890
4891	//===--------------------------------------------------------------------===//
4892	// Expression Parsing Callbacks: SemaExpr.cpp.
4893
4894	bool CanUseDecl(NamedDecl D, bool* TreatUnavailableAsInvalid);
4895	bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
4896	const ObjCInterfaceDecl UnknownObjCClass = nullptr*,
4897	bool ObjCPropertyAccess = false,
4898	bool AvoidPartialAvailabilityChecks = false,
4899	ObjCInterfaceDecl ClassReciever = nullptr*);
4900	void NoteDeletedFunction(FunctionDecl *FD);
4901	void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);
4902	bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
4903	ObjCMethodDecl *Getter,
4904	SourceLocation Loc);
4905	void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
4906	ArrayRef<Expr *> Args);
4907
4908	void PushExpressionEvaluationContext(
4909	ExpressionEvaluationContext NewContext, Decl LambdaContextDecl = nullptr*,
4910	ExpressionEvaluationContextRecord::ExpressionKind Type =
4911	ExpressionEvaluationContextRecord::EK_Other);
4912	enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };
4913	void PushExpressionEvaluationContext(
4914	ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
4915	ExpressionEvaluationContextRecord::ExpressionKind Type =
4916	ExpressionEvaluationContextRecord::EK_Other);
4917	void PopExpressionEvaluationContext();
4918
4919	void DiscardCleanupsInEvaluationContext();
4920
4921	ExprResult TransformToPotentiallyEvaluated(Expr *E);
4922	ExprResult HandleExprEvaluationContextForTypeof(Expr *E);
4923
4924	ExprResult CheckUnevaluatedOperand(Expr *E);
4925	void CheckUnusedVolatileAssignment(Expr *E);
4926
4927	ExprResult ActOnConstantExpression(ExprResult Res);
4928
4929	// Functions for marking a declaration referenced. These functions also
4930	// contain the relevant logic for marking if a reference to a function or
4931	// variable is an odr-use (in the C++11 sense). There are separate variants
4932	// for expressions referring to a decl; these exist because odr-use marking
4933	// needs to be delayed for some constant variables when we build one of the
4934	// named expressions.
4935	//
4936	// MightBeOdrUse indicates whether the use could possibly be an odr-use, and
4937	// should usually be true. This only needs to be set to false if the lack of
4938	// odr-use cannot be determined from the current context (for instance,
4939	// because the name denotes a virtual function and was written without an
4940	// explicit nested-name-specifier).
4941	void MarkAnyDeclReferenced(SourceLocation Loc, Decl D, bool* MightBeOdrUse);
4942	void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
4943	bool MightBeOdrUse = true);
4944	void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
4945	void MarkDeclRefReferenced(DeclRefExpr E, const* Expr Base = nullptr*);
4946	void MarkMemberReferenced(MemberExpr *E);
4947	void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E);
4948	void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc,
4949	unsigned CapturingScopeIndex);
4950
4951	ExprResult CheckLValueToRValueConversionOperand(Expr *E);
4952	void CleanupVarDeclMarking();
4953
4954	enum TryCaptureKind {
4955	TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
4956	};
4957
4958	/// Try to capture the given variable.
4959	///
4960	/// \param Var The variable to capture.
4961	///
4962	/// \param Loc The location at which the capture occurs.
4963	///
4964	/// \param Kind The kind of capture, which may be implicit (for either a
4965	/// block or a lambda), or explicit by-value or by-reference (for a lambda).
4966	///
4967	/// \param EllipsisLoc The location of the ellipsis, if one is provided in
4968	/// an explicit lambda capture.
4969	///
4970	/// \param BuildAndDiagnose Whether we are actually supposed to add the
4971	/// captures or diagnose errors. If false, this routine merely check whether
4972	/// the capture can occur without performing the capture itself or complaining
4973	/// if the variable cannot be captured.
4974	///
4975	/// \param CaptureType Will be set to the type of the field used to capture
4976	/// this variable in the innermost block or lambda. Only valid when the
4977	/// variable can be captured.
4978	///
4979	/// \param DeclRefType Will be set to the type of a reference to the capture
4980	/// from within the current scope. Only valid when the variable can be
4981	/// captured.
4982	///
4983	/// \param FunctionScopeIndexToStopAt If non-null, it points to the index
4984	/// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
4985	/// This is useful when enclosing lambdas must speculatively capture
4986	/// variables that may or may not be used in certain specializations of
4987	/// a nested generic lambda.
4988	///
4989	/// \returns true if an error occurred (i.e., the variable cannot be
4990	/// captured) and false if the capture succeeded.
4991	bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
4992	SourceLocation EllipsisLoc, bool BuildAndDiagnose,
4993	QualType &CaptureType,
4994	QualType &DeclRefType,
4995	const unsigned *const FunctionScopeIndexToStopAt);
4996
4997	/// Try to capture the given variable.
4998	bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
4999	TryCaptureKind Kind = TryCapture_Implicit,
5000	SourceLocation EllipsisLoc = SourceLocation ());
5001
5002	/// Checks if the variable must be captured.
5003	bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);
5004
5005	/// Given a variable, determine the type that a reference to that
5006	/// variable will have in the given scope.
5007	QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);
5008
5009	/// Mark all of the declarations referenced within a particular AST node as
5010	/// referenced. Used when template instantiation instantiates a non-dependent
5011	/// type -- entities referenced by the type are now referenced.
5012	void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);
5013	void MarkDeclarationsReferencedInExpr(Expr *E,
5014	bool SkipLocalVariables = false);
5015
5016	/// Try to recover by turning the given expression into a
5017	/// call. Returns true if recovery was attempted or an error was
5018	/// emitted; this may also leave the ExprResult invalid.
5019	bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
5020	bool ForceComplain = false,
5021	bool (IsPlausibleResult)(QualType) = nullptr*);
5022
5023	/// Figure out if an expression could be turned into a call.
5024	bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
5025	UnresolvedSetImpl &NonTemplateOverloads);
5026
5027	/// Try to convert an expression \p E to type \p Ty. Returns the result of the
5028	/// conversion.
5029	ExprResult tryConvertExprToType(Expr *E, QualType Ty);
5030
5031	/// Conditionally issue a diagnostic based on the current
5032	/// evaluation context.
5033	///
5034	/// \param Statement If Statement is non-null, delay reporting the
5035	/// diagnostic until the function body is parsed, and then do a basic
5036	/// reachability analysis to determine if the statement is reachable.
5037	/// If it is unreachable, the diagnostic will not be emitted.
5038	bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
5039	const PartialDiagnostic &PD);
5040	/// Similar, but diagnostic is only produced if all the specified statements
5041	/// are reachable.
5042	bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
5043	const PartialDiagnostic &PD);
5044
5045	// Primary Expressions.
5046	SourceRange getExprRange(Expr E) const*;
5047
5048	ExprResult ActOnIdExpression(
5049	Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
5050	UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,
5051	CorrectionCandidateCallback CCC = nullptr*,
5052	bool IsInlineAsmIdentifier = false, Token KeywordReplacement = nullptr*);
5053
5054	void DecomposeUnqualifiedId(const UnqualifiedId &Id,
5055	TemplateArgumentListInfo &Buffer,
5056	DeclarationNameInfo &NameInfo,
5057	const TemplateArgumentListInfo *&TemplateArgs);
5058
5059	bool DiagnoseDependentMemberLookup(LookupResult &R);
5060
5061	bool
5062	DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
5063	CorrectionCandidateCallback &CCC,
5064	TemplateArgumentListInfo ExplicitTemplateArgs = nullptr*,
5065	ArrayRef<Expr > Args = None, TypoExpr Out = nullptr*);
5066
5067	DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S,
5068	IdentifierInfo *II);
5069	ExprResult BuildIvarRefExpr(Scope S, SourceLocation Loc, ObjCIvarDecl IV);
5070
5071	ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,
5072	IdentifierInfo *II,
5073	bool AllowBuiltinCreation=false);
5074
5075	ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
5076	SourceLocation TemplateKWLoc,
5077	const DeclarationNameInfo &NameInfo,
5078	bool isAddressOfOperand,
5079	const TemplateArgumentListInfo *TemplateArgs);
5080
5081	/// If \p D cannot be odr-used in the current expression evaluation context,
5082	/// return a reason explaining why. Otherwise, return NOUR_None.
5083	NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D);
5084
5085	DeclRefExpr BuildDeclRefExpr(ValueDecl D, QualType Ty, ExprValueKind VK,
5086	SourceLocation Loc,
5087	const CXXScopeSpec SS = nullptr*);
5088	DeclRefExpr *
5089	BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5090	const DeclarationNameInfo &NameInfo,
5091	const CXXScopeSpec SS = nullptr*,
5092	NamedDecl FoundD = nullptr*,
5093	SourceLocation TemplateKWLoc = SourceLocation (),
5094	const TemplateArgumentListInfo TemplateArgs = nullptr*);
5095	DeclRefExpr *
5096	BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5097	const DeclarationNameInfo &NameInfo,
5098	NestedNameSpecifierLoc NNS,
5099	NamedDecl FoundD = nullptr*,
5100	SourceLocation TemplateKWLoc = SourceLocation (),
5101	const TemplateArgumentListInfo TemplateArgs = nullptr*);
5102
5103	ExprResult
5104	BuildAnonymousStructUnionMemberReference(
5105	const CXXScopeSpec &SS,
5106	SourceLocation nameLoc,
5107	IndirectFieldDecl *indirectField,
5108	DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),
5109	Expr baseObjectExpr = nullptr*,
5110	SourceLocation opLoc = SourceLocation ());
5111
5112	ExprResult BuildPossibleImplicitMemberExpr(
5113	const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,
5114	const TemplateArgumentListInfo TemplateArgs, const* Scope *S,
5115	UnresolvedLookupExpr AsULE = nullptr*);
5116	ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
5117	SourceLocation TemplateKWLoc,
5118	LookupResult &R,
5119	const TemplateArgumentListInfo *TemplateArgs,
5120	bool IsDefiniteInstance,
5121	const Scope *S);
5122	bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
5123	const LookupResult &R,
5124	bool HasTrailingLParen);
5125
5126	ExprResult
5127	BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
5128	const DeclarationNameInfo &NameInfo,
5129	bool IsAddressOfOperand, const Scope *S,
5130	TypeSourceInfo RecoveryTSI = nullptr**);
5131
5132	ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
5133	SourceLocation TemplateKWLoc,
5134	const DeclarationNameInfo &NameInfo,
5135	const TemplateArgumentListInfo *TemplateArgs);
5136
5137	ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
5138	LookupResult &R,
5139	bool NeedsADL,
5140	bool AcceptInvalidDecl = false);
5141	ExprResult BuildDeclarationNameExpr(
5142	const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
5143	NamedDecl FoundD = nullptr*,
5144	const TemplateArgumentListInfo TemplateArgs = nullptr*,
5145	bool AcceptInvalidDecl = false);
5146
5147	ExprResult BuildLiteralOperatorCall(LookupResult &R,
5148	DeclarationNameInfo &SuffixInfo,
5149	ArrayRef<Expr *> Args,
5150	SourceLocation LitEndLoc,
5151	TemplateArgumentListInfo ExplicitTemplateArgs = nullptr*);
5152
5153	ExprResult BuildPredefinedExpr(SourceLocation Loc,
5154	PredefinedExpr::IdentKind IK);
5155	ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
5156	ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
5157
5158	bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);
5159
5160	ExprResult ActOnNumericConstant(const Token &Tok, Scope UDLScope = nullptr*);
5161	ExprResult ActOnCharacterConstant(const Token &Tok,
5162	Scope UDLScope = nullptr*);
5163	ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
5164	ExprResult ActOnParenListExpr(SourceLocation L,
5165	SourceLocation R,
5166	MultiExprArg Val);
5167
5168	/// ActOnStringLiteral - The specified tokens were lexed as pasted string
5169	/// fragments (e.g. "foo" "bar" L"baz").
5170	ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks,
5171	Scope UDLScope = nullptr*);
5172
5173	ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,
5174	SourceLocation DefaultLoc,
5175	SourceLocation RParenLoc,
5176	Expr *ControllingExpr,
5177	ArrayRef<ParsedType> ArgTypes,
5178	ArrayRef<Expr *> ArgExprs);
5179	ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,
5180	SourceLocation DefaultLoc,
5181	SourceLocation RParenLoc,
5182	Expr *ControllingExpr,
5183	ArrayRef<TypeSourceInfo *> Types,
5184	ArrayRef<Expr *> Exprs);
5185
5186	// Binary/Unary Operators. 'Tok' is the token for the operator.
5187	ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
5188	Expr *InputExpr);
5189	ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
5190	UnaryOperatorKind Opc, Expr *Input);
5191	ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
5192	tok::TokenKind Op, Expr *Input);
5193
5194	bool isQualifiedMemberAccess(Expr *E);
5195	QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
5196
5197	ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
5198	SourceLocation OpLoc,
5199	UnaryExprOrTypeTrait ExprKind,
5200	SourceRange R);
5201	ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
5202	UnaryExprOrTypeTrait ExprKind);
5203	ExprResult
5204	ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
5205	UnaryExprOrTypeTrait ExprKind,
5206	bool IsType, void *TyOrEx,
5207	SourceRange ArgRange);
5208
5209	ExprResult CheckPlaceholderExpr(Expr *E);
5210	bool CheckVecStepExpr(Expr *E);
5211
5212	bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
5213	bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,
5214	SourceRange ExprRange,
5215	UnaryExprOrTypeTrait ExprKind);
5216	ExprResult ActOnSizeofParameterPackExpr(Scope *S,
5217	SourceLocation OpLoc,
5218	IdentifierInfo &Name,
5219	SourceLocation NameLoc,
5220	SourceLocation RParenLoc);
5221	ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
5222	tok::TokenKind Kind, Expr *Input);
5223
5224	ExprResult ActOnArraySubscriptExpr(Scope S, Expr Base, SourceLocation LLoc,
5225	Expr *Idx, SourceLocation RLoc);
5226	ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
5227	Expr *Idx, SourceLocation RLoc);
5228
5229	ExprResult CreateBuiltinMatrixSubscriptExpr(Expr Base, Expr RowIdx,
5230	Expr *ColumnIdx,
5231	SourceLocation RBLoc);
5232
5233	ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
5234	Expr *LowerBound,
5235	SourceLocation ColonLocFirst,
5236	SourceLocation ColonLocSecond,
5237	Expr Length, Expr Stride,
5238	SourceLocation RBLoc);
5239	ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
5240	SourceLocation RParenLoc,
5241	ArrayRef<Expr *> Dims,
5242	ArrayRef<SourceRange> Brackets);
5243
5244	/// Data structure for iterator expression.
5245	struct OMPIteratorData {
5246	IdentifierInfo DeclIdent = nullptr*;
5247	SourceLocation DeclIdentLoc;
5248	ParsedType Type;
5249	OMPIteratorExpr::IteratorRange Range;
5250	SourceLocation AssignLoc;
5251	SourceLocation ColonLoc;
5252	SourceLocation SecColonLoc;
5253	};
5254
5255	ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc,
5256	SourceLocation LLoc, SourceLocation RLoc,
5257	ArrayRef<OMPIteratorData> Data);
5258
5259	// This struct is for use by ActOnMemberAccess to allow
5260	// BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after
5261	// changing the access operator from a '.' to a '->' (to see if that is the
5262	// change needed to fix an error about an unknown member, e.g. when the class
5263	// defines a custom operator->).
5264	struct ActOnMemberAccessExtraArgs {
5265	Scope *S;
5266	UnqualifiedId &Id;
5267	Decl *ObjCImpDecl;
5268	};
5269
5270	ExprResult BuildMemberReferenceExpr(
5271	Expr Base, QualType BaseType, SourceLocation OpLoc, bool* IsArrow,
5272	CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
5273	NamedDecl FirstQualifierInScope, const* DeclarationNameInfo &NameInfo,
5274	const TemplateArgumentListInfo *TemplateArgs,
5275	const Scope *S,
5276	ActOnMemberAccessExtraArgs ExtraArgs = nullptr*);
5277
5278	ExprResult
5279	BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
5280	bool IsArrow, const CXXScopeSpec &SS,
5281	SourceLocation TemplateKWLoc,
5282	NamedDecl *FirstQualifierInScope, LookupResult &R,
5283	const TemplateArgumentListInfo *TemplateArgs,
5284	const Scope *S,
5285	bool SuppressQualifierCheck = false,
5286	ActOnMemberAccessExtraArgs ExtraArgs = nullptr*);
5287
5288	ExprResult BuildFieldReferenceExpr(Expr BaseExpr, bool* IsArrow,
5289	SourceLocation OpLoc,
5290	const CXXScopeSpec &SS, FieldDecl *Field,
5291	DeclAccessPair FoundDecl,
5292	const DeclarationNameInfo &MemberNameInfo);
5293
5294	ExprResult PerformMemberExprBaseConversion(Expr Base, bool* IsArrow);
5295
5296	bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
5297	const CXXScopeSpec &SS,
5298	const LookupResult &R);
5299
5300	ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,
5301	bool IsArrow, SourceLocation OpLoc,
5302	const CXXScopeSpec &SS,
5303	SourceLocation TemplateKWLoc,
5304	NamedDecl *FirstQualifierInScope,
5305	const DeclarationNameInfo &NameInfo,
5306	const TemplateArgumentListInfo *TemplateArgs);
5307
5308	ExprResult ActOnMemberAccessExpr(Scope S, Expr Base,
5309	SourceLocation OpLoc,
5310	tok::TokenKind OpKind,
5311	CXXScopeSpec &SS,
5312	SourceLocation TemplateKWLoc,
5313	UnqualifiedId &Member,
5314	Decl *ObjCImpDecl);
5315
5316	MemberExpr *
5317	BuildMemberExpr(Expr Base, bool* IsArrow, SourceLocation OpLoc,
5318	const CXXScopeSpec *SS, SourceLocation TemplateKWLoc,
5319	ValueDecl *Member, DeclAccessPair FoundDecl,
5320	bool HadMultipleCandidates,
5321	const DeclarationNameInfo &MemberNameInfo, QualType Ty,
5322	ExprValueKind VK, ExprObjectKind OK,
5323	const TemplateArgumentListInfo TemplateArgs = nullptr*);
5324	MemberExpr *
5325	BuildMemberExpr(Expr Base, bool* IsArrow, SourceLocation OpLoc,
5326	NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
5327	ValueDecl *Member, DeclAccessPair FoundDecl,
5328	bool HadMultipleCandidates,
5329	const DeclarationNameInfo &MemberNameInfo, QualType Ty,
5330	ExprValueKind VK, ExprObjectKind OK,
5331	const TemplateArgumentListInfo TemplateArgs = nullptr*);
5332
5333	void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
5334	bool ConvertArgumentsForCall(CallExpr Call, Expr Fn,
5335	FunctionDecl *FDecl,
5336	const FunctionProtoType *Proto,
5337	ArrayRef<Expr *> Args,
5338	SourceLocation RParenLoc,
5339	bool ExecConfig = false);
5340	void CheckStaticArrayArgument(SourceLocation CallLoc,
5341	ParmVarDecl *Param,
5342	const Expr *ArgExpr);
5343
5344	/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
5345	/// This provides the location of the left/right parens and a list of comma
5346	/// locations.
5347	ExprResult ActOnCallExpr(Scope S, Expr Fn, SourceLocation LParenLoc,
5348	MultiExprArg ArgExprs, SourceLocation RParenLoc,
5349	Expr ExecConfig = nullptr*);
5350	ExprResult BuildCallExpr(Scope S, Expr Fn, SourceLocation LParenLoc,
5351	MultiExprArg ArgExprs, SourceLocation RParenLoc,
5352	Expr ExecConfig = nullptr*,
5353	bool IsExecConfig = false,
5354	bool AllowRecovery = false);
5355	enum class AtomicArgumentOrder { API, AST };
5356	ExprResult
5357	BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
5358	SourceLocation RParenLoc, MultiExprArg Args,
5359	AtomicExpr::AtomicOp Op,
5360	AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API);
5361	ExprResult
5362	BuildResolvedCallExpr(Expr Fn, NamedDecl NDecl, SourceLocation LParenLoc,
5363	ArrayRef<Expr *> Arg, SourceLocation RParenLoc,
5364	Expr Config = nullptr, bool* IsExecConfig = false,
5365	ADLCallKind UsesADL = ADLCallKind::NotADL);
5366
5367	ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
5368	MultiExprArg ExecConfig,
5369	SourceLocation GGGLoc);
5370
5371	ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
5372	Declarator &D, ParsedType &Ty,
5373	SourceLocation RParenLoc, Expr *CastExpr);
5374	ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
5375	TypeSourceInfo *Ty,
5376	SourceLocation RParenLoc,
5377	Expr *Op);
5378	CastKind PrepareScalarCast(ExprResult &src, QualType destType);
5379
5380	/// Build an altivec or OpenCL literal.
5381	ExprResult BuildVectorLiteral(SourceLocation LParenLoc,
5382	SourceLocation RParenLoc, Expr *E,
5383	TypeSourceInfo *TInfo);
5384
5385	ExprResult MaybeConvertParenListExprToParenExpr(Scope S, Expr ME);
5386
5387	ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
5388	ParsedType Ty,
5389	SourceLocation RParenLoc,
5390	Expr *InitExpr);
5391
5392	ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
5393	TypeSourceInfo *TInfo,
5394	SourceLocation RParenLoc,
5395	Expr *LiteralExpr);
5396
5397	ExprResult ActOnInitList(SourceLocation LBraceLoc,
5398	MultiExprArg InitArgList,
5399	SourceLocation RBraceLoc);
5400
5401	ExprResult BuildInitList(SourceLocation LBraceLoc,
5402	MultiExprArg InitArgList,
5403	SourceLocation RBraceLoc);
5404
5405	ExprResult ActOnDesignatedInitializer(Designation &Desig,
5406	SourceLocation EqualOrColonLoc,
5407	bool GNUSyntax,
5408	ExprResult Init);
5409
5410	private:
5411	static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
5412
5413	public:
5414	ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
5415	tok::TokenKind Kind, Expr LHSExpr, Expr RHSExpr);
5416	ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
5417	BinaryOperatorKind Opc, Expr LHSExpr, Expr RHSExpr);
5418	ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
5419	Expr LHSExpr, Expr RHSExpr);
5420	void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
5421	UnresolvedSetImpl &Functions);
5422
5423	void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
5424
5425	/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
5426	/// in the case of a the GNU conditional expr extension.
5427	ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
5428	SourceLocation ColonLoc,
5429	Expr CondExpr, Expr LHSExpr, Expr *RHSExpr);
5430
5431	/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
5432	ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
5433	LabelDecl *TheDecl);
5434
5435	void ActOnStartStmtExpr();
5436	ExprResult ActOnStmtExpr(Scope S, SourceLocation LPLoc, Stmt SubStmt,
5437	SourceLocation RPLoc);
5438	ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
5439	SourceLocation RPLoc, unsigned TemplateDepth);
5440	// Handle the final expression in a statement expression.
5441	ExprResult ActOnStmtExprResult(ExprResult E);
5442	void ActOnStmtExprError();
5443
5444	// __builtin_offsetof(type, identifier(.identifier\|[expr]))*
5445	struct OffsetOfComponent {
5446	SourceLocation LocStart, LocEnd;
5447	bool isBrackets; // true if [expr], false if .ident
5448	union {
5449	IdentifierInfo *IdentInfo;
5450	Expr *E;
5451	} U;
5452	};
5453
5454	/// __builtin_offsetof(type, a.b[123][456].c)
5455	ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
5456	TypeSourceInfo *TInfo,
5457	ArrayRef<OffsetOfComponent> Components,
5458	SourceLocation RParenLoc);
5459	ExprResult ActOnBuiltinOffsetOf(Scope *S,
5460	SourceLocation BuiltinLoc,
5461	SourceLocation TypeLoc,
5462	ParsedType ParsedArgTy,
5463	ArrayRef<OffsetOfComponent> Components,
5464	SourceLocation RParenLoc);
5465
5466	// __builtin_choose_expr(constExpr, expr1, expr2)
5467	ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
5468	Expr CondExpr, Expr LHSExpr,
5469	Expr *RHSExpr, SourceLocation RPLoc);
5470
5471	// __builtin_va_arg(expr, type)
5472	ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
5473	SourceLocation RPLoc);
5474	ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
5475	TypeSourceInfo *TInfo, SourceLocation RPLoc);
5476
5477	// __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(),
5478	// __builtin_COLUMN()
5479	ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,
5480	SourceLocation BuiltinLoc,
5481	SourceLocation RPLoc);
5482
5483	// Build a potentially resolved SourceLocExpr.
5484	ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
5485	SourceLocation BuiltinLoc, SourceLocation RPLoc,
5486	DeclContext *ParentContext);
5487
5488	// __null
5489	ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
5490
5491	bool CheckCaseExpression(Expr *E);
5492
5493	/// Describes the result of an "if-exists" condition check.
5494	enum IfExistsResult {
5495	/// The symbol exists.
5496	IER_Exists,
5497
5498	/// The symbol does not exist.
5499	IER_DoesNotExist,
5500
5501	/// The name is a dependent name, so the results will differ
5502	/// from one instantiation to the next.
5503	IER_Dependent,
5504
5505	/// An error occurred.
5506	IER_Error
5507	};
5508
5509	IfExistsResult
5510	CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,
5511	const DeclarationNameInfo &TargetNameInfo);
5512
5513	IfExistsResult
5514	CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
5515	bool IsIfExists, CXXScopeSpec &SS,
5516	UnqualifiedId &Name);
5517
5518	StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
5519	bool IsIfExists,
5520	NestedNameSpecifierLoc QualifierLoc,
5521	DeclarationNameInfo NameInfo,
5522	Stmt *Nested);
5523	StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
5524	bool IsIfExists,
5525	CXXScopeSpec &SS, UnqualifiedId &Name,
5526	Stmt *Nested);
5527
5528	//===------------------------- "Block" Extension ------------------------===//
5529
5530	/// ActOnBlockStart - This callback is invoked when a block literal is
5531	/// started.
5532	void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
5533
5534	/// ActOnBlockArguments - This callback allows processing of block arguments.
5535	/// If there are no arguments, this is still invoked.
5536	void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
5537	Scope *CurScope);
5538
5539	/// ActOnBlockError - If there is an error parsing a block, this callback
5540	/// is invoked to pop the information about the block from the action impl.
5541	void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
5542
5543	/// ActOnBlockStmtExpr - This is called when the body of a block statement
5544	/// literal was successfully completed. ^(int x){...}
5545	ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
5546	Scope *CurScope);
5547
5548	//===---------------------------- Clang Extensions ----------------------===//
5549
5550	/// __builtin_convertvector(...)
5551	ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
5552	SourceLocation BuiltinLoc,
5553	SourceLocation RParenLoc);
5554
5555	//===---------------------------- OpenCL Features -----------------------===//
5556
5557	/// __builtin_astype(...)
5558	ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
5559	SourceLocation BuiltinLoc,
5560	SourceLocation RParenLoc);
5561
5562	//===---------------------------- C++ Features --------------------------===//
5563
5564	// Act on C++ namespaces
5565	Decl ActOnStartNamespaceDef(Scope S, SourceLocation InlineLoc,
5566	SourceLocation NamespaceLoc,
5567	SourceLocation IdentLoc, IdentifierInfo *Ident,
5568	SourceLocation LBrace,
5569	const ParsedAttributesView &AttrList,
5570	UsingDirectiveDecl *&UsingDecl);
5571	void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
5572
5573	NamespaceDecl getStdNamespace() const*;
5574	NamespaceDecl *getOrCreateStdNamespace();
5575
5576	NamespaceDecl *lookupStdExperimentalNamespace();
5577
5578	CXXRecordDecl getStdBadAlloc() const*;
5579	EnumDecl getStdAlignValT() const*;
5580
5581	private:
5582	// A cache representing if we've fully checked the various comparison category
5583	// types stored in ASTContext. The bit-index corresponds to the integer value
5584	// of a ComparisonCategoryType enumerator.
5585	llvm::SmallBitVector FullyCheckedComparisonCategories;
5586
5587	ValueDecl tryLookupCtorInitMemberDecl(CXXRecordDecl ClassDecl,
5588	CXXScopeSpec &SS,
5589	ParsedType TemplateTypeTy,
5590	IdentifierInfo *MemberOrBase);
5591
5592	public:
5593	enum class ComparisonCategoryUsage {
5594	/// The '<=>' operator was used in an expression and a builtin operator
5595	/// was selected.
5596	OperatorInExpression,
5597	/// A defaulted 'operator<=>' needed the comparison category. This
5598	/// typically only applies to 'std::strong_ordering', due to the implicit
5599	/// fallback return value.
5600	DefaultedOperator,
5601	};
5602
5603	/// Lookup the specified comparison category types in the standard
5604	/// library, an check the VarDecls possibly returned by the operator<=>
5605	/// builtins for that type.
5606	///
5607	/// \return The type of the comparison category type corresponding to the
5608	/// specified Kind, or a null type if an error occurs
5609	QualType CheckComparisonCategoryType(ComparisonCategoryType Kind,
5610	SourceLocation Loc,
5611	ComparisonCategoryUsage Usage);
5612
5613	/// Tests whether Ty is an instance of std::initializer_list and, if
5614	/// it is and Element is not NULL, assigns the element type to Element.
5615	bool isStdInitializerList(QualType Ty, QualType *Element);
5616
5617	/// Looks for the std::initializer_list template and instantiates it
5618	/// with Element, or emits an error if it's not found.
5619	///
5620	/// \returns The instantiated template, or null on error.
5621	QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);
5622
5623	/// Determine whether Ctor is an initializer-list constructor, as
5624	/// defined in [dcl.init.list]p2.
5625	bool isInitListConstructor(const FunctionDecl *Ctor);
5626
5627	Decl ActOnUsingDirective(Scope CurScope, SourceLocation UsingLoc,
5628	SourceLocation NamespcLoc, CXXScopeSpec &SS,
5629	SourceLocation IdentLoc,
5630	IdentifierInfo *NamespcName,
5631	const ParsedAttributesView &AttrList);
5632
5633	void PushUsingDirective(Scope S, UsingDirectiveDecl UDir);
5634
5635	Decl ActOnNamespaceAliasDef(Scope CurScope,
5636	SourceLocation NamespaceLoc,
5637	SourceLocation AliasLoc,
5638	IdentifierInfo *Alias,
5639	CXXScopeSpec &SS,
5640	SourceLocation IdentLoc,
5641	IdentifierInfo *Ident);
5642
5643	void HideUsingShadowDecl(Scope S, UsingShadowDecl Shadow);
5644	bool CheckUsingShadowDecl(UsingDecl UD, NamedDecl Target,
5645	const LookupResult &PreviousDecls,
5646	UsingShadowDecl *&PrevShadow);
5647	UsingShadowDecl BuildUsingShadowDecl(Scope S, UsingDecl *UD,
5648	NamedDecl *Target,
5649	UsingShadowDecl *PrevDecl);
5650
5651	bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
5652	bool HasTypenameKeyword,
5653	const CXXScopeSpec &SS,
5654	SourceLocation NameLoc,
5655	const LookupResult &Previous);
5656	bool CheckUsingDeclQualifier(SourceLocation UsingLoc,
5657	bool HasTypename,
5658	const CXXScopeSpec &SS,
5659	const DeclarationNameInfo &NameInfo,
5660	SourceLocation NameLoc);
5661
5662	NamedDecl *BuildUsingDeclaration(
5663	Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
5664	bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
5665	DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
5666	const ParsedAttributesView &AttrList, bool IsInstantiation);
5667	NamedDecl BuildUsingPackDecl(NamedDecl InstantiatedFrom,
5668	ArrayRef<NamedDecl *> Expansions);
5669
5670	bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
5671
5672	/// Given a derived-class using shadow declaration for a constructor and the
5673	/// correspnding base class constructor, find or create the implicit
5674	/// synthesized derived class constructor to use for this initialization.
5675	CXXConstructorDecl *
5676	findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,
5677	ConstructorUsingShadowDecl *DerivedShadow);
5678
5679	Decl ActOnUsingDeclaration(Scope CurScope, AccessSpecifier AS,
5680	SourceLocation UsingLoc,
5681	SourceLocation TypenameLoc, CXXScopeSpec &SS,
5682	UnqualifiedId &Name, SourceLocation EllipsisLoc,
5683	const ParsedAttributesView &AttrList);
5684	Decl ActOnAliasDeclaration(Scope CurScope, AccessSpecifier AS,
5685	MultiTemplateParamsArg TemplateParams,
5686	SourceLocation UsingLoc, UnqualifiedId &Name,
5687	const ParsedAttributesView &AttrList,
5688	TypeResult Type, Decl *DeclFromDeclSpec);
5689
5690	/// BuildCXXConstructExpr - Creates a complete call to a constructor,
5691	/// including handling of its default argument expressions.
5692	///
5693	/// \param ConstructKind - a CXXConstructExpr::ConstructionKind
5694	ExprResult
5695	BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5696	NamedDecl *FoundDecl,
5697	CXXConstructorDecl *Constructor, MultiExprArg Exprs,
5698	bool HadMultipleCandidates, bool IsListInitialization,
5699	bool IsStdInitListInitialization,
5700	bool RequiresZeroInit, unsigned ConstructKind,
5701	SourceRange ParenRange);
5702
5703	/// Build a CXXConstructExpr whose constructor has already been resolved if
5704	/// it denotes an inherited constructor.
5705	ExprResult
5706	BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5707	CXXConstructorDecl Constructor, bool* Elidable,
5708	MultiExprArg Exprs,
5709	bool HadMultipleCandidates, bool IsListInitialization,
5710	bool IsStdInitListInitialization,
5711	bool RequiresZeroInit, unsigned ConstructKind,
5712	SourceRange ParenRange);
5713
5714	// FIXME: Can we remove this and have the above BuildCXXConstructExpr check if
5715	// the constructor can be elidable?
5716	ExprResult
5717	BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5718	NamedDecl *FoundDecl,
5719	CXXConstructorDecl Constructor, bool* Elidable,
5720	MultiExprArg Exprs, bool HadMultipleCandidates,
5721	bool IsListInitialization,
5722	bool IsStdInitListInitialization, bool RequiresZeroInit,
5723	unsigned ConstructKind, SourceRange ParenRange);
5724
5725	ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
5726
5727
5728	/// Instantiate or parse a C++ default argument expression as necessary.
5729	/// Return true on error.
5730	bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
5731	ParmVarDecl *Param);
5732
5733	/// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
5734	/// the default expr if needed.
5735	ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
5736	FunctionDecl *FD,
5737	ParmVarDecl *Param);
5738
5739	/// FinalizeVarWithDestructor - Prepare for calling destructor on the
5740	/// constructed variable.
5741	void FinalizeVarWithDestructor(VarDecl VD, const* RecordType *DeclInitType);
5742
5743	/// Helper class that collects exception specifications for
5744	/// implicitly-declared special member functions.
5745	class ImplicitExceptionSpecification {
5746	// Pointer to allow copying
5747	Sema *Self;
5748	// We order exception specifications thus:
5749	// noexcept is the most restrictive, but is only used in C++11.
5750	// throw() comes next.
5751	// Then a throw(collected exceptions)
5752	// Finally no specification, which is expressed as noexcept(false).
5753	// throw(...) is used instead if any called function uses it.
5754	ExceptionSpecificationType ComputedEST;
5755	llvm::SmallPtrSet<CanQualType, `4`> ExceptionsSeen;
5756	SmallVector<QualType, `4`> Exceptions;
5757
5758	void ClearExceptions() {
5759	ExceptionsSeen.clear();
5760	Exceptions.clear();
5761	}
5762
5763	public:
5764	explicit ImplicitExceptionSpecification(Sema &Self)
5765	: Self(&Self), ComputedEST(EST_BasicNoexcept) {
5766	if (!Self.getLangOpts().CPlusPlus11)
5767	ComputedEST = EST_DynamicNone;
5768	}
5769
5770	/// Get the computed exception specification type.
5771	ExceptionSpecificationType getExceptionSpecType() const {
5772	assert(!isComputedNoexcept(ComputedEST) &&
5773	"noexcept(expr) should not be a possible result");
5774	return ComputedEST;
5775	}
5776
5777	/// The number of exceptions in the exception specification.
5778	unsigned size() const { return Exceptions.size(); }
5779
5780	/// The set of exceptions in the exception specification.
5781	const QualType data() const* { return Exceptions.data(); }
5782
5783	/// Integrate another called method into the collected data.
5784	void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method);
5785
5786	/// Integrate an invoked expression into the collected data.
5787	void CalledExpr(Expr *E) { CalledStmt(E); }
5788
5789	/// Integrate an invoked statement into the collected data.
5790	void CalledStmt(Stmt *S);
5791
5792	/// Overwrite an EPI's exception specification with this
5793	/// computed exception specification.
5794	FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const {
5795	FunctionProtoType::ExceptionSpecInfo ESI;
5796	ESI.Type = getExceptionSpecType();
5797	if (ESI.Type == EST_Dynamic) {
5798	ESI.Exceptions = Exceptions;
5799	} else if (ESI.Type == EST_None) {
5800	/// C++11 [except.spec]p14:
5801	/// The exception-specification is noexcept(false) if the set of
5802	/// potential exceptions of the special member function contains "any"
5803	ESI.Type = EST_NoexceptFalse;
5804	ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation (),
5805	tok::kw_false).get();
5806	}
5807	return ESI;
5808	}
5809	};
5810
5811	/// Evaluate the implicit exception specification for a defaulted
5812	/// special member function.
5813	void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD);
5814
5815	/// Check the given noexcept-specifier, convert its expression, and compute
5816	/// the appropriate ExceptionSpecificationType.
5817	ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr,
5818	ExceptionSpecificationType &EST);
5819
5820	/// Check the given exception-specification and update the
5821	/// exception specification information with the results.
5822	void checkExceptionSpecification(bool IsTopLevel,
5823	ExceptionSpecificationType EST,
5824	ArrayRef<ParsedType> DynamicExceptions,
5825	ArrayRef<SourceRange> DynamicExceptionRanges,
5826	Expr *NoexceptExpr,
5827	SmallVectorImpl<QualType> &Exceptions,
5828	FunctionProtoType::ExceptionSpecInfo &ESI);
5829
5830	/// Determine if we're in a case where we need to (incorrectly) eagerly
5831	/// parse an exception specification to work around a libstdc++ bug.
5832	bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D);
5833
5834	/// Add an exception-specification to the given member function
5835	/// (or member function template). The exception-specification was parsed
5836	/// after the method itself was declared.
5837	void actOnDelayedExceptionSpecification(Decl *Method,
5838	ExceptionSpecificationType EST,
5839	SourceRange SpecificationRange,
5840	ArrayRef<ParsedType> DynamicExceptions,
5841	ArrayRef<SourceRange> DynamicExceptionRanges,
5842	Expr *NoexceptExpr);
5843
5844	class InheritedConstructorInfo;
5845
5846	/// Determine if a special member function should have a deleted
5847	/// definition when it is defaulted.
5848	bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
5849	InheritedConstructorInfo ICI = nullptr*,
5850	bool Diagnose = false);
5851
5852	/// Produce notes explaining why a defaulted function was defined as deleted.
5853	void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD);
5854
5855	/// Declare the implicit default constructor for the given class.
5856	///
5857	/// \param ClassDecl The class declaration into which the implicit
5858	/// default constructor will be added.
5859	///
5860	/// \returns The implicitly-declared default constructor.
5861	CXXConstructorDecl *DeclareImplicitDefaultConstructor(
5862	CXXRecordDecl *ClassDecl);
5863
5864	/// DefineImplicitDefaultConstructor - Checks for feasibility of
5865	/// defining this constructor as the default constructor.
5866	void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
5867	CXXConstructorDecl *Constructor);
5868
5869	/// Declare the implicit destructor for the given class.
5870	///
5871	/// \param ClassDecl The class declaration into which the implicit
5872	/// destructor will be added.
5873	///
5874	/// \returns The implicitly-declared destructor.
5875	CXXDestructorDecl DeclareImplicitDestructor(CXXRecordDecl ClassDecl);
5876
5877	/// DefineImplicitDestructor - Checks for feasibility of
5878	/// defining this destructor as the default destructor.
5879	void DefineImplicitDestructor(SourceLocation CurrentLocation,
5880	CXXDestructorDecl *Destructor);
5881
5882	/// Build an exception spec for destructors that don't have one.
5883	///
5884	/// C++11 says that user-defined destructors with no exception spec get one
5885	/// that looks as if the destructor was implicitly declared.
5886	void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor);
5887
5888	/// Define the specified inheriting constructor.
5889	void DefineInheritingConstructor(SourceLocation UseLoc,
5890	CXXConstructorDecl *Constructor);
5891
5892	/// Declare the implicit copy constructor for the given class.
5893	///
5894	/// \param ClassDecl The class declaration into which the implicit
5895	/// copy constructor will be added.
5896	///
5897	/// \returns The implicitly-declared copy constructor.
5898	CXXConstructorDecl DeclareImplicitCopyConstructor(CXXRecordDecl ClassDecl);
5899
5900	/// DefineImplicitCopyConstructor - Checks for feasibility of
5901	/// defining this constructor as the copy constructor.
5902	void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
5903	CXXConstructorDecl *Constructor);
5904
5905	/// Declare the implicit move constructor for the given class.
5906	///
5907	/// \param ClassDecl The Class declaration into which the implicit
5908	/// move constructor will be added.
5909	///
5910	/// \returns The implicitly-declared move constructor, or NULL if it wasn't
5911	/// declared.
5912	CXXConstructorDecl DeclareImplicitMoveConstructor(CXXRecordDecl ClassDecl);
5913
5914	/// DefineImplicitMoveConstructor - Checks for feasibility of
5915	/// defining this constructor as the move constructor.
5916	void DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
5917	CXXConstructorDecl *Constructor);
5918
5919	/// Declare the implicit copy assignment operator for the given class.
5920	///
5921	/// \param ClassDecl The class declaration into which the implicit
5922	/// copy assignment operator will be added.
5923	///
5924	/// \returns The implicitly-declared copy assignment operator.
5925	CXXMethodDecl DeclareImplicitCopyAssignment(CXXRecordDecl ClassDecl);
5926
5927	/// Defines an implicitly-declared copy assignment operator.
5928	void DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
5929	CXXMethodDecl *MethodDecl);
5930
5931	/// Declare the implicit move assignment operator for the given class.
5932	///
5933	/// \param ClassDecl The Class declaration into which the implicit
5934	/// move assignment operator will be added.
5935	///
5936	/// \returns The implicitly-declared move assignment operator, or NULL if it
5937	/// wasn't declared.
5938	CXXMethodDecl DeclareImplicitMoveAssignment(CXXRecordDecl ClassDecl);
5939
5940	/// Defines an implicitly-declared move assignment operator.
5941	void DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
5942	CXXMethodDecl *MethodDecl);
5943
5944	/// Force the declaration of any implicitly-declared members of this
5945	/// class.
5946	void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class);
5947
5948	/// Check a completed declaration of an implicit special member.
5949	void CheckImplicitSpecialMemberDeclaration(Scope S, FunctionDecl FD);
5950
5951	/// Determine whether the given function is an implicitly-deleted
5952	/// special member function.
5953	bool isImplicitlyDeleted(FunctionDecl *FD);
5954
5955	/// Check whether 'this' shows up in the type of a static member
5956	/// function after the (naturally empty) cv-qualifier-seq would be.
5957	///
5958	/// \returns true if an error occurred.
5959	bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method);
5960
5961	/// Whether this' shows up in the exception specification of a static
5962	/// member function.
5963	bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method);
5964
5965	/// Check whether 'this' shows up in the attributes of the given
5966	/// static member function.
5967	///
5968	/// \returns true if an error occurred.
5969	bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);
5970
5971	/// MaybeBindToTemporary - If the passed in expression has a record type with
5972	/// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
5973	/// it simply returns the passed in expression.
5974	ExprResult MaybeBindToTemporary(Expr *E);
5975
5976	/// Wrap the expression in a ConstantExpr if it is a potential immediate
5977	/// invocation.
5978	ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl);
5979
5980	bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
5981	MultiExprArg ArgsPtr,
5982	SourceLocation Loc,
5983	SmallVectorImpl<Expr*> &ConvertedArgs,
5984	bool AllowExplicit = false,
5985	bool IsListInitialization = false);
5986
5987	ParsedType getInheritingConstructorName(CXXScopeSpec &SS,
5988	SourceLocation NameLoc,
5989	IdentifierInfo &Name);
5990
5991	ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc,
5992	Scope *S, CXXScopeSpec &SS,
5993	bool EnteringContext);
5994	ParsedType getDestructorName(SourceLocation TildeLoc,
5995	IdentifierInfo &II, SourceLocation NameLoc,
5996	Scope *S, CXXScopeSpec &SS,
5997	ParsedType ObjectType,
5998	bool EnteringContext);
5999
6000	ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,
6001	ParsedType ObjectType);
6002
6003	// Checks that reinterpret casts don't have undefined behavior.
6004	void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
6005	bool IsDereference, SourceRange Range);
6006
6007	/// ActOnCXXNamedCast - Parse
6008	/// {dynamic,static,reinterpret,const,addrspace}_cast's.
6009	ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
6010	tok::TokenKind Kind,
6011	SourceLocation LAngleBracketLoc,
6012	Declarator &D,
6013	SourceLocation RAngleBracketLoc,
6014	SourceLocation LParenLoc,
6015	Expr *E,
6016	SourceLocation RParenLoc);
6017
6018	ExprResult BuildCXXNamedCast(SourceLocation OpLoc,
6019	tok::TokenKind Kind,
6020	TypeSourceInfo *Ty,
6021	Expr *E,
6022	SourceRange AngleBrackets,
6023	SourceRange Parens);
6024
6025	ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl,
6026	ExprResult Operand,
6027	SourceLocation RParenLoc);
6028
6029	ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI,
6030	Expr *Operand, SourceLocation RParenLoc);
6031
6032	ExprResult BuildCXXTypeId(QualType TypeInfoType,
6033	SourceLocation TypeidLoc,
6034	TypeSourceInfo *Operand,
6035	SourceLocation RParenLoc);
6036	ExprResult BuildCXXTypeId(QualType TypeInfoType,
6037	SourceLocation TypeidLoc,
6038	Expr *Operand,
6039	SourceLocation RParenLoc);
6040
6041	/// ActOnCXXTypeid - Parse typeid( something ).
6042	ExprResult ActOnCXXTypeid(SourceLocation OpLoc,
6043	SourceLocation LParenLoc, bool isType,
6044	void *TyOrExpr,
6045	SourceLocation RParenLoc);
6046
6047	ExprResult BuildCXXUuidof(QualType TypeInfoType,
6048	SourceLocation TypeidLoc,
6049	TypeSourceInfo *Operand,
6050	SourceLocation RParenLoc);
6051	ExprResult BuildCXXUuidof(QualType TypeInfoType,
6052	SourceLocation TypeidLoc,
6053	Expr *Operand,
6054	SourceLocation RParenLoc);
6055
6056	/// ActOnCXXUuidof - Parse __uuidof( something ).
6057	ExprResult ActOnCXXUuidof(SourceLocation OpLoc,
6058	SourceLocation LParenLoc, bool isType,
6059	void *TyOrExpr,
6060	SourceLocation RParenLoc);
6061
6062	/// Handle a C++1z fold-expression: ( expr op ... op expr ).
6063	ExprResult ActOnCXXFoldExpr(Scope S, SourceLocation LParenLoc, Expr LHS,
6064	tok::TokenKind Operator,
6065	SourceLocation EllipsisLoc, Expr *RHS,
6066	SourceLocation RParenLoc);
6067	ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee,
6068	SourceLocation LParenLoc, Expr *LHS,
6069	BinaryOperatorKind Operator,
6070	SourceLocation EllipsisLoc, Expr *RHS,
6071	SourceLocation RParenLoc,
6072	Optional<unsigned> NumExpansions);
6073	ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
6074	BinaryOperatorKind Operator);
6075
6076	//// ActOnCXXThis - Parse 'this' pointer.
6077	ExprResult ActOnCXXThis(SourceLocation loc);
6078
6079	/// Build a CXXThisExpr and mark it referenced in the current context.
6080	Expr BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool* IsImplicit);
6081	void MarkThisReferenced(CXXThisExpr *This);
6082
6083	/// Try to retrieve the type of the 'this' pointer.
6084	///
6085	/// \returns The type of 'this', if possible. Otherwise, returns a NULL type.
6086	QualType getCurrentThisType();
6087
6088	/// When non-NULL, the C++ 'this' expression is allowed despite the
6089	/// current context not being a non-static member function. In such cases,
6090	/// this provides the type used for 'this'.
6091	QualType CXXThisTypeOverride;
6092
6093	/// RAII object used to temporarily allow the C++ 'this' expression
6094	/// to be used, with the given qualifiers on the current class type.
6095	class CXXThisScopeRAII {
6096	Sema &S;
6097	QualType OldCXXThisTypeOverride;
6098	bool Enabled;
6099
6100	public:
6101	/// Introduce a new scope where 'this' may be allowed (when enabled),
6102	/// using the given declaration (which is either a class template or a
6103	/// class) along with the given qualifiers.
6104	/// along with the qualifiers placed on 'this'.*
6105	CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals,
6106	bool Enabled = true);
6107
6108	~CXXThisScopeRAII();
6109	};
6110
6111	/// Make sure the value of 'this' is actually available in the current
6112	/// context, if it is a potentially evaluated context.
6113	///
6114	/// \param Loc The location at which the capture of 'this' occurs.
6115	///
6116	/// \param Explicit Whether 'this' is explicitly captured in a lambda
6117	/// capture list.
6118	///
6119	/// \param FunctionScopeIndexToStopAt If non-null, it points to the index
6120	/// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
6121	/// This is useful when enclosing lambdas must speculatively capture
6122	/// 'this' that may or may not be used in certain specializations of
6123	/// a nested generic lambda (depending on whether the name resolves to
6124	/// a non-static member function or a static function).
6125	/// \return returns 'true' if failed, 'false' if success.
6126	bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false,
6127	bool BuildAndDiagnose = true,
6128	const unsigned *const FunctionScopeIndexToStopAt = nullptr,
6129	bool ByCopy = false);
6130
6131	/// Determine whether the given type is the type of this that is used*
6132	/// outside of the body of a member function for a type that is currently
6133	/// being defined.
6134	bool isThisOutsideMemberFunctionBody(QualType BaseType);
6135
6136	/// ActOnCXXBoolLiteral - Parse {true,false} literals.
6137	ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
6138
6139
6140	/// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
6141	ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
6142
6143	ExprResult
6144	ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs,
6145	SourceLocation AtLoc, SourceLocation RParen);
6146
6147	/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
6148	ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
6149
6150	//// ActOnCXXThrow - Parse throw expressions.
6151	ExprResult ActOnCXXThrow(Scope S, SourceLocation OpLoc, Expr expr);
6152	ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
6153	bool IsThrownVarInScope);
6154	bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);
6155
6156	/// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
6157	/// Can be interpreted either as function-style casting ("int(x)")
6158	/// or class type construction ("ClassType(x,y,z)")
6159	/// or creation of a value-initialized type ("int()").
6160	ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep,
6161	SourceLocation LParenOrBraceLoc,
6162	MultiExprArg Exprs,
6163	SourceLocation RParenOrBraceLoc,
6164	bool ListInitialization);
6165
6166	ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type,
6167	SourceLocation LParenLoc,
6168	MultiExprArg Exprs,
6169	SourceLocation RParenLoc,
6170	bool ListInitialization);
6171
6172	/// ActOnCXXNew - Parsed a C++ 'new' expression.
6173	ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
6174	SourceLocation PlacementLParen,
6175	MultiExprArg PlacementArgs,
6176	SourceLocation PlacementRParen,
6177	SourceRange TypeIdParens, Declarator &D,
6178	Expr *Initializer);
6179	ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal,
6180	SourceLocation PlacementLParen,
6181	MultiExprArg PlacementArgs,
6182	SourceLocation PlacementRParen,
6183	SourceRange TypeIdParens,
6184	QualType AllocType,
6185	TypeSourceInfo *AllocTypeInfo,
6186	Optional<Expr *> ArraySize,
6187	SourceRange DirectInitRange,
6188	Expr *Initializer);
6189
6190	/// Determine whether \p FD is an aligned allocation or deallocation
6191	/// function that is unavailable.
6192	bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const;
6193
6194	/// Produce diagnostics if \p FD is an aligned allocation or deallocation
6195	/// function that is unavailable.
6196	void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD,
6197	SourceLocation Loc);
6198
6199	bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
6200	SourceRange R);
6201
6202	/// The scope in which to find allocation functions.
6203	enum AllocationFunctionScope {
6204	/// Only look for allocation functions in the global scope.
6205	AFS_Global,
6206	/// Only look for allocation functions in the scope of the
6207	/// allocated class.
6208	AFS_Class,
6209	/// Look for allocation functions in both the global scope
6210	/// and in the scope of the allocated class.
6211	AFS_Both
6212	};
6213
6214	/// Finds the overloads of operator new and delete that are appropriate
6215	/// for the allocation.
6216	bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
6217	AllocationFunctionScope NewScope,
6218	AllocationFunctionScope DeleteScope,
6219	QualType AllocType, bool IsArray,
6220	bool &PassAlignment, MultiExprArg PlaceArgs,
6221	FunctionDecl *&OperatorNew,
6222	FunctionDecl *&OperatorDelete,
6223	bool Diagnose = true);
6224	void DeclareGlobalNewDelete();
6225	void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
6226	ArrayRef<QualType> Params);
6227
6228	bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
6229	DeclarationName Name, FunctionDecl* &Operator,
6230	bool Diagnose = true);
6231	FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
6232	bool CanProvideSize,
6233	bool Overaligned,
6234	DeclarationName Name);
6235	FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
6236	CXXRecordDecl *RD);
6237
6238	/// ActOnCXXDelete - Parsed a C++ 'delete' expression
6239	ExprResult ActOnCXXDelete(SourceLocation StartLoc,
6240	bool UseGlobal, bool ArrayForm,
6241	Expr *Operand);
6242	void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
6243	bool IsDelete, bool CallCanBeVirtual,
6244	bool WarnOnNonAbstractTypes,
6245	SourceLocation DtorLoc);
6246
6247	ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen,
6248	Expr *Operand, SourceLocation RParen);
6249	ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
6250	SourceLocation RParen);
6251
6252	/// Parsed one of the type trait support pseudo-functions.
6253	ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
6254	ArrayRef<ParsedType> Args,
6255	SourceLocation RParenLoc);
6256	ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
6257	ArrayRef<TypeSourceInfo *> Args,
6258	SourceLocation RParenLoc);
6259
6260	/// ActOnArrayTypeTrait - Parsed one of the binary type trait support
6261	/// pseudo-functions.
6262	ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT,
6263	SourceLocation KWLoc,
6264	ParsedType LhsTy,
6265	Expr *DimExpr,
6266	SourceLocation RParen);
6267
6268	ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT,
6269	SourceLocation KWLoc,
6270	TypeSourceInfo *TSInfo,
6271	Expr *DimExpr,
6272	SourceLocation RParen);
6273
6274	/// ActOnExpressionTrait - Parsed one of the unary type trait support
6275	/// pseudo-functions.
6276	ExprResult ActOnExpressionTrait(ExpressionTrait OET,
6277	SourceLocation KWLoc,
6278	Expr *Queried,
6279	SourceLocation RParen);
6280
6281	ExprResult BuildExpressionTrait(ExpressionTrait OET,
6282	SourceLocation KWLoc,
6283	Expr *Queried,
6284	SourceLocation RParen);
6285
6286	ExprResult ActOnStartCXXMemberReference(Scope *S,
6287	Expr *Base,
6288	SourceLocation OpLoc,
6289	tok::TokenKind OpKind,
6290	ParsedType &ObjectType,
6291	bool &MayBePseudoDestructor);
6292
6293	ExprResult BuildPseudoDestructorExpr(Expr *Base,
6294	SourceLocation OpLoc,
6295	tok::TokenKind OpKind,
6296	const CXXScopeSpec &SS,
6297	TypeSourceInfo *ScopeType,
6298	SourceLocation CCLoc,
6299	SourceLocation TildeLoc,
6300	PseudoDestructorTypeStorage DestroyedType);
6301
6302	ExprResult ActOnPseudoDestructorExpr(Scope S, Expr Base,
6303	SourceLocation OpLoc,
6304	tok::TokenKind OpKind,
6305	CXXScopeSpec &SS,
6306	UnqualifiedId &FirstTypeName,
6307	SourceLocation CCLoc,
6308	SourceLocation TildeLoc,
6309	UnqualifiedId &SecondTypeName);
6310
6311	ExprResult ActOnPseudoDestructorExpr(Scope S, Expr Base,
6312	SourceLocation OpLoc,
6313	tok::TokenKind OpKind,
6314	SourceLocation TildeLoc,
6315	const DeclSpec& DS);
6316
6317	/// MaybeCreateExprWithCleanups - If the current full-expression
6318	/// requires any cleanups, surround it with a ExprWithCleanups node.
6319	/// Otherwise, just returns the passed-in expression.
6320	Expr MaybeCreateExprWithCleanups(Expr SubExpr);
6321	Stmt MaybeCreateStmtWithCleanups(Stmt SubStmt);
6322	ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);
6323
6324	MaterializeTemporaryExpr *
6325	CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
6326	bool BoundToLvalueReference);
6327
6328	ExprResult ActOnFinishFullExpr(Expr Expr, bool* DiscardedValue) {
6329	return ActOnFinishFullExpr(
6330	Expr, Expr ? Expr->getExprLoc() : SourceLocation (), DiscardedValue);
6331	}
6332	ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
6333	bool DiscardedValue, bool IsConstexpr = false);
6334	StmtResult ActOnFinishFullStmt(Stmt *Stmt);
6335
6336	// Marks SS invalid if it represents an incomplete type.
6337	bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
6338
6339	DeclContext *computeDeclContext(QualType T);
6340	DeclContext computeDeclContext(const* CXXScopeSpec &SS,
6341	bool EnteringContext = false);
6342	bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
6343	CXXRecordDecl getCurrentInstantiationOf(NestedNameSpecifier NNS);
6344
6345	/// The parser has parsed a global nested-name-specifier '::'.
6346	///
6347	/// \param CCLoc The location of the '::'.
6348	///
6349	/// \param SS The nested-name-specifier, which will be updated in-place
6350	/// to reflect the parsed nested-name-specifier.
6351	///
6352	/// \returns true if an error occurred, false otherwise.
6353	bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS);
6354
6355	/// The parser has parsed a '__super' nested-name-specifier.
6356	///
6357	/// \param SuperLoc The location of the '__super' keyword.
6358	///
6359	/// \param ColonColonLoc The location of the '::'.
6360	///
6361	/// \param SS The nested-name-specifier, which will be updated in-place
6362	/// to reflect the parsed nested-name-specifier.
6363	///
6364	/// \returns true if an error occurred, false otherwise.
6365	bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
6366	SourceLocation ColonColonLoc, CXXScopeSpec &SS);
6367
6368	bool isAcceptableNestedNameSpecifier(const NamedDecl *SD,
6369	bool CanCorrect = nullptr*);
6370	NamedDecl FindFirstQualifierInScope(Scope S, NestedNameSpecifier *NNS);
6371
6372	/// Keeps information about an identifier in a nested-name-spec.
6373	///
6374	struct NestedNameSpecInfo {
6375	/// The type of the object, if we're parsing nested-name-specifier in
6376	/// a member access expression.
6377	ParsedType ObjectType;
6378
6379	/// The identifier preceding the '::'.
6380	IdentifierInfo *Identifier;
6381
6382	/// The location of the identifier.
6383	SourceLocation IdentifierLoc;
6384
6385	/// The location of the '::'.
6386	SourceLocation CCLoc;
6387
6388	/// Creates info object for the most typical case.
6389	NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
6390	SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType ())
6391	: ObjectType (ObjectType), Identifier(II), IdentifierLoc (IdLoc),
6392	CCLoc (ColonColonLoc) {
6393	}
6394
6395	NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
6396	SourceLocation ColonColonLoc, QualType ObjectType)
6397	: ObjectType (ParsedType::make(ObjectType)), Identifier(II),
6398	IdentifierLoc (IdLoc), CCLoc (ColonColonLoc) {
6399	}
6400	};
6401
6402	bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
6403	NestedNameSpecInfo &IdInfo);
6404
6405	bool BuildCXXNestedNameSpecifier(Scope *S,
6406	NestedNameSpecInfo &IdInfo,
6407	bool EnteringContext,
6408	CXXScopeSpec &SS,
6409	NamedDecl *ScopeLookupResult,
6410	bool ErrorRecoveryLookup,
6411	bool IsCorrectedToColon = nullptr*,
6412	bool OnlyNamespace = false);
6413
6414	/// The parser has parsed a nested-name-specifier 'identifier::'.
6415	///
6416	/// \param S The scope in which this nested-name-specifier occurs.
6417	///
6418	/// \param IdInfo Parser information about an identifier in the
6419	/// nested-name-spec.
6420	///
6421	/// \param EnteringContext Whether we're entering the context nominated by
6422	/// this nested-name-specifier.
6423	///
6424	/// \param SS The nested-name-specifier, which is both an input
6425	/// parameter (the nested-name-specifier before this type) and an
6426	/// output parameter (containing the full nested-name-specifier,
6427	/// including this new type).
6428	///
6429	/// \param ErrorRecoveryLookup If true, then this method is called to improve
6430	/// error recovery. In this case do not emit error message.
6431	///
6432	/// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'
6433	/// are allowed. The bool value pointed by this parameter is set to 'true'
6434	/// if the identifier is treated as if it was followed by ':', not '::'.
6435	///
6436	/// \param OnlyNamespace If true, only considers namespaces in lookup.
6437	///
6438	/// \returns true if an error occurred, false otherwise.
6439	bool ActOnCXXNestedNameSpecifier(Scope *S,
6440	NestedNameSpecInfo &IdInfo,
6441	bool EnteringContext,
6442	CXXScopeSpec &SS,
6443	bool ErrorRecoveryLookup = false,
6444	bool IsCorrectedToColon = nullptr*,
6445	bool OnlyNamespace = false);
6446
6447	ExprResult ActOnDecltypeExpression(Expr *E);
6448
6449	bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
6450	const DeclSpec &DS,
6451	SourceLocation ColonColonLoc);
6452
6453	bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
6454	NestedNameSpecInfo &IdInfo,
6455	bool EnteringContext);
6456
6457	/// The parser has parsed a nested-name-specifier
6458	/// 'template[opt] template-name < template-args >::'.
6459	///
6460	/// \param S The scope in which this nested-name-specifier occurs.
6461	///
6462	/// \param SS The nested-name-specifier, which is both an input
6463	/// parameter (the nested-name-specifier before this type) and an
6464	/// output parameter (containing the full nested-name-specifier,
6465	/// including this new type).
6466	///
6467	/// \param TemplateKWLoc the location of the 'template' keyword, if any.
6468	/// \param TemplateName the template name.
6469	/// \param TemplateNameLoc The location of the template name.
6470	/// \param LAngleLoc The location of the opening angle bracket ('<').
6471	/// \param TemplateArgs The template arguments.
6472	/// \param RAngleLoc The location of the closing angle bracket ('>').
6473	/// \param CCLoc The location of the '::'.
6474	///
6475	/// \param EnteringContext Whether we're entering the context of the
6476	/// nested-name-specifier.
6477	///
6478	///
6479	/// \returns true if an error occurred, false otherwise.
6480	bool ActOnCXXNestedNameSpecifier(Scope *S,
6481	CXXScopeSpec &SS,
6482	SourceLocation TemplateKWLoc,
6483	TemplateTy TemplateName,
6484	SourceLocation TemplateNameLoc,
6485	SourceLocation LAngleLoc,
6486	ASTTemplateArgsPtr TemplateArgs,
6487	SourceLocation RAngleLoc,
6488	SourceLocation CCLoc,
6489	bool EnteringContext);
6490
6491	/// Given a C++ nested-name-specifier, produce an annotation value
6492	/// that the parser can use later to reconstruct the given
6493	/// nested-name-specifier.
6494	///
6495	/// \param SS A nested-name-specifier.
6496	///
6497	/// \returns A pointer containing all of the information in the
6498	/// nested-name-specifier \p SS.
6499	void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS);
6500
6501	/// Given an annotation pointer for a nested-name-specifier, restore
6502	/// the nested-name-specifier structure.
6503	///
6504	/// \param Annotation The annotation pointer, produced by
6505	/// \c SaveNestedNameSpecifierAnnotation().
6506	///
6507	/// \param AnnotationRange The source range corresponding to the annotation.
6508	///
6509	/// \param SS The nested-name-specifier that will be updated with the contents
6510	/// of the annotation pointer.
6511	void RestoreNestedNameSpecifierAnnotation(void *Annotation,
6512	SourceRange AnnotationRange,
6513	CXXScopeSpec &SS);
6514
6515	bool ShouldEnterDeclaratorScope(Scope S, const* CXXScopeSpec &SS);
6516
6517	/// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
6518	/// scope or nested-name-specifier) is parsed, part of a declarator-id.
6519	/// After this method is called, according to [C++ 3.4.3p3], names should be
6520	/// looked up in the declarator-id's scope, until the declarator is parsed and
6521	/// ActOnCXXExitDeclaratorScope is called.
6522	/// The 'SS' should be a non-empty valid CXXScopeSpec.
6523	bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS);
6524
6525	/// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
6526	/// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
6527	/// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
6528	/// Used to indicate that names should revert to being looked up in the
6529	/// defining scope.
6530	void ActOnCXXExitDeclaratorScope(Scope S, const* CXXScopeSpec &SS);
6531
6532	/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
6533	/// initializer for the declaration 'Dcl'.
6534	/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
6535	/// static data member of class X, names should be looked up in the scope of
6536	/// class X.
6537	void ActOnCXXEnterDeclInitializer(Scope S, Decl Dcl);
6538
6539	/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
6540	/// initializer for the declaration 'Dcl'.
6541	void ActOnCXXExitDeclInitializer(Scope S, Decl Dcl);
6542
6543	/// Create a new lambda closure type.
6544	CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
6545	TypeSourceInfo *Info,
6546	bool KnownDependent,
6547	LambdaCaptureDefault CaptureDefault);
6548
6549	/// Start the definition of a lambda expression.
6550	CXXMethodDecl startLambdaDefinition(CXXRecordDecl Class,
6551	SourceRange IntroducerRange,
6552	TypeSourceInfo *MethodType,
6553	SourceLocation EndLoc,
6554	ArrayRef<ParmVarDecl *> Params,
6555	ConstexprSpecKind ConstexprKind,
6556	Expr *TrailingRequiresClause);
6557
6558	/// Number lambda for linkage purposes if necessary.
6559	void handleLambdaNumbering(
6560	CXXRecordDecl Class, CXXMethodDecl Method,
6561	Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None);
6562
6563	/// Endow the lambda scope info with the relevant properties.
6564	void buildLambdaScope(sema::LambdaScopeInfo *LSI,
6565	CXXMethodDecl *CallOperator,
6566	SourceRange IntroducerRange,
6567	LambdaCaptureDefault CaptureDefault,
6568	SourceLocation CaptureDefaultLoc,
6569	bool ExplicitParams,
6570	bool ExplicitResultType,
6571	bool Mutable);
6572
6573	/// Perform initialization analysis of the init-capture and perform
6574	/// any implicit conversions such as an lvalue-to-rvalue conversion if
6575	/// not being used to initialize a reference.
6576	ParsedType actOnLambdaInitCaptureInitialization(
6577	SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
6578	IdentifierInfo Id, LambdaCaptureInitKind InitKind, Expr &Init) {
6579	return ParsedType::make(buildLambdaInitCaptureInitialization(
6580	Loc, ByRef, EllipsisLoc, None, Id,
6581	InitKind != LambdaCaptureInitKind::CopyInit, Init));
6582	}
6583	QualType buildLambdaInitCaptureInitialization(
6584	SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
6585	Optional<unsigned> NumExpansions, IdentifierInfo Id, bool* DirectInit,
6586	Expr *&Init);
6587
6588	/// Create a dummy variable within the declcontext of the lambda's
6589	/// call operator, for name lookup purposes for a lambda init capture.
6590	///
6591	/// CodeGen handles emission of lambda captures, ignoring these dummy
6592	/// variables appropriately.
6593	VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,
6594	QualType InitCaptureType,
6595	SourceLocation EllipsisLoc,
6596	IdentifierInfo *Id,
6597	unsigned InitStyle, Expr *Init);
6598
6599	/// Add an init-capture to a lambda scope.
6600	void addInitCapture(sema::LambdaScopeInfo LSI, VarDecl Var);
6601
6602	/// Note that we have finished the explicit captures for the
6603	/// given lambda.
6604	void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);
6605
6606	/// \brief This is called after parsing the explicit template parameter list
6607	/// on a lambda (if it exists) in C++2a.
6608	void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,
6609	ArrayRef<NamedDecl *> TParams,
6610	SourceLocation RAngleLoc,
6611	ExprResult RequiresClause);
6612
6613	/// Introduce the lambda parameters into scope.
6614	void addLambdaParameters(
6615	ArrayRef<LambdaIntroducer::LambdaCapture> Captures,
6616	CXXMethodDecl CallOperator, Scope CurScope);
6617
6618	/// Deduce a block or lambda's return type based on the return
6619	/// statements present in the body.
6620	void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);
6621
6622	/// ActOnStartOfLambdaDefinition - This is called just before we start
6623	/// parsing the body of a lambda; it analyzes the explicit captures and
6624	/// arguments, and sets up various data-structures for the body of the
6625	/// lambda.
6626	void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
6627	Declarator &ParamInfo, Scope *CurScope);
6628
6629	/// ActOnLambdaError - If there is an error parsing a lambda, this callback
6630	/// is invoked to pop the information about the lambda.
6631	void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
6632	bool IsInstantiation = false);
6633
6634	/// ActOnLambdaExpr - This is called when the body of a lambda expression
6635	/// was successfully completed.
6636	ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
6637	Scope *CurScope);
6638
6639	/// Does copying/destroying the captured variable have side effects?
6640	bool CaptureHasSideEffects(const sema::Capture &From);
6641
6642	/// Diagnose if an explicit lambda capture is unused. Returns true if a
6643	/// diagnostic is emitted.
6644	bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange,
6645	const sema::Capture &From);
6646
6647	/// Build a FieldDecl suitable to hold the given capture.
6648	FieldDecl BuildCaptureField(RecordDecl RD, const sema::Capture &Capture);
6649
6650	/// Initialize the given capture with a suitable expression.
6651	ExprResult BuildCaptureInit(const sema::Capture &Capture,
6652	SourceLocation ImplicitCaptureLoc,
6653	bool IsOpenMPMapping = false);
6654
6655	/// Complete a lambda-expression having processed and attached the
6656	/// lambda body.
6657	ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
6658	sema::LambdaScopeInfo *LSI);
6659
6660	/// Get the return type to use for a lambda's conversion function(s) to
6661	/// function pointer type, given the type of the call operator.
6662	QualType
6663	getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType,
6664	CallingConv CC);
6665
6666	/// Define the "body" of the conversion from a lambda object to a
6667	/// function pointer.
6668	///
6669	/// This routine doesn't actually define a sensible body; rather, it fills
6670	/// in the initialization expression needed to copy the lambda object into
6671	/// the block, and IR generation actually generates the real body of the
6672	/// block pointer conversion.
6673	void DefineImplicitLambdaToFunctionPointerConversion(
6674	SourceLocation CurrentLoc, CXXConversionDecl *Conv);
6675
6676	/// Define the "body" of the conversion from a lambda object to a
6677	/// block pointer.
6678	///
6679	/// This routine doesn't actually define a sensible body; rather, it fills
6680	/// in the initialization expression needed to copy the lambda object into
6681	/// the block, and IR generation actually generates the real body of the
6682	/// block pointer conversion.
6683	void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc,
6684	CXXConversionDecl *Conv);
6685
6686	ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
6687	SourceLocation ConvLocation,
6688	CXXConversionDecl *Conv,
6689	Expr *Src);
6690
6691	/// Check whether the given expression is a valid constraint expression.
6692	/// A diagnostic is emitted if it is not, false is returned, and
6693	/// PossibleNonPrimary will be set to true if the failure might be due to a
6694	/// non-primary expression being used as an atomic constraint.
6695	bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token (),
6696	bool PossibleNonPrimary = nullptr*,
6697	bool IsTrailingRequiresClause = false);
6698
6699	private:
6700	/// Caches pairs of template-like decls whose associated constraints were
6701	/// checked for subsumption and whether or not the first's constraints did in
6702	/// fact subsume the second's.
6703	llvm::DenseMap<std::pair<NamedDecl , NamedDecl >, bool> SubsumptionCache;
6704	/// Caches the normalized associated constraints of declarations (concepts or
6705	/// constrained declarations). If an error occurred while normalizing the
6706	/// associated constraints of the template or concept, nullptr will be cached
6707	/// here.
6708	llvm::DenseMap<NamedDecl , NormalizedConstraint >
6709	NormalizationCache;
6710
6711	llvm::ContextualFoldingSet<ConstraintSatisfaction, const ASTContext &>
6712	SatisfactionCache;
6713
6714	public:
6715	const NormalizedConstraint *
6716	getNormalizedAssociatedConstraints(
6717	NamedDecl ConstrainedDecl, ArrayRef<const* Expr *> AssociatedConstraints);
6718
6719	/// \brief Check whether the given declaration's associated constraints are
6720	/// at least as constrained than another declaration's according to the
6721	/// partial ordering of constraints.
6722	///
6723	/// \param Result If no error occurred, receives the result of true if D1 is
6724	/// at least constrained than D2, and false otherwise.
6725	///
6726	/// \returns true if an error occurred, false otherwise.
6727	bool IsAtLeastAsConstrained(NamedDecl D1, ArrayRef<const* Expr *> AC1,
6728	NamedDecl D2, ArrayRef<const* Expr *> AC2,
6729	bool &Result);
6730
6731	/// If D1 was not at least as constrained as D2, but would've been if a pair
6732	/// of atomic constraints involved had been declared in a concept and not
6733	/// repeated in two separate places in code.
6734	/// \returns true if such a diagnostic was emitted, false otherwise.
6735	bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
6736	ArrayRef<const Expr > AC1, NamedDecl D2, ArrayRef<const Expr *> AC2);
6737
6738	/// \brief Check whether the given list of constraint expressions are
6739	/// satisfied (as if in a 'conjunction') given template arguments.
6740	/// \param Template the template-like entity that triggered the constraints
6741	/// check (either a concept or a constrained entity).
6742	/// \param ConstraintExprs a list of constraint expressions, treated as if
6743	/// they were 'AND'ed together.
6744	/// \param TemplateArgs the list of template arguments to substitute into the
6745	/// constraint expression.
6746	/// \param TemplateIDRange The source range of the template id that
6747	/// caused the constraints check.
6748	/// \param Satisfaction if true is returned, will contain details of the
6749	/// satisfaction, with enough information to diagnose an unsatisfied
6750	/// expression.
6751	/// \returns true if an error occurred and satisfaction could not be checked,
6752	/// false otherwise.
6753	bool CheckConstraintSatisfaction(
6754	const NamedDecl Template, ArrayRef<const* Expr *> ConstraintExprs,
6755	ArrayRef<TemplateArgument> TemplateArgs,
6756	SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);
6757
6758	/// \brief Check whether the given non-dependent constraint expression is
6759	/// satisfied. Returns false and updates Satisfaction with the satisfaction
6760	/// verdict if successful, emits a diagnostic and returns true if an error
6761	/// occured and satisfaction could not be determined.
6762	///
6763	/// \returns true if an error occurred, false otherwise.
6764	bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,
6765	ConstraintSatisfaction &Satisfaction);
6766
6767	/// Check whether the given function decl's trailing requires clause is
6768	/// satisfied, if any. Returns false and updates Satisfaction with the
6769	/// satisfaction verdict if successful, emits a diagnostic and returns true if
6770	/// an error occured and satisfaction could not be determined.
6771	///
6772	/// \returns true if an error occurred, false otherwise.
6773	bool CheckFunctionConstraints(const FunctionDecl *FD,
6774	ConstraintSatisfaction &Satisfaction,
6775	SourceLocation UsageLoc = SourceLocation ());
6776
6777
6778	/// \brief Ensure that the given template arguments satisfy the constraints
6779	/// associated with the given template, emitting a diagnostic if they do not.
6780	///
6781	/// \param Template The template to which the template arguments are being
6782	/// provided.
6783	///
6784	/// \param TemplateArgs The converted, canonicalized template arguments.
6785	///
6786	/// \param TemplateIDRange The source range of the template id that
6787	/// caused the constraints check.
6788	///
6789	/// \returns true if the constrains are not satisfied or could not be checked
6790	/// for satisfaction, false if the constraints are satisfied.
6791	bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template,
6792	ArrayRef<TemplateArgument> TemplateArgs,
6793	SourceRange TemplateIDRange);
6794
6795	/// \brief Emit diagnostics explaining why a constraint expression was deemed
6796	/// unsatisfied.
6797	/// \param First whether this is the first time an unsatisfied constraint is
6798	/// diagnosed for this error.
6799	void
6800	DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction,
6801	bool First = true);
6802
6803	/// \brief Emit diagnostics explaining why a constraint expression was deemed
6804	/// unsatisfied.
6805	void
6806	DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction,
6807	bool First = true);
6808
6809	// ParseObjCStringLiteral - Parse Objective-C string literals.
6810	ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
6811	ArrayRef<Expr *> Strings);
6812
6813	ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);
6814
6815	/// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
6816	/// numeric literal expression. Type of the expression will be "NSNumber "*
6817	/// or "id" if NSNumber is unavailable.
6818	ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);
6819	ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc,
6820	bool Value);
6821	ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements);
6822
6823	/// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the
6824	/// '@' prefixed parenthesized expression. The type of the expression will
6825	/// either be "NSNumber ", "NSString " or "NSValue " depending on the type*
6826	/// of ValueType, which is allowed to be a built-in numeric type, "char ",*
6827	/// "const char " or C structure with attribute 'objc_boxable'.*
6828	ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);
6829
6830	ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
6831	Expr *IndexExpr,
6832	ObjCMethodDecl *getterMethod,
6833	ObjCMethodDecl *setterMethod);
6834
6835	ExprResult BuildObjCDictionaryLiteral(SourceRange SR,
6836	MutableArrayRef<ObjCDictionaryElement> Elements);
6837
6838	ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc,
6839	TypeSourceInfo *EncodedTypeInfo,
6840	SourceLocation RParenLoc);
6841	ExprResult BuildCXXMemberCallExpr(Expr Exp, NamedDecl FoundDecl,
6842	CXXConversionDecl *Method,
6843	bool HadMultipleCandidates);
6844
6845	ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
6846	SourceLocation EncodeLoc,
6847	SourceLocation LParenLoc,
6848	ParsedType Ty,
6849	SourceLocation RParenLoc);
6850
6851	/// ParseObjCSelectorExpression - Build selector expression for \@selector
6852	ExprResult ParseObjCSelectorExpression(Selector Sel,
6853	SourceLocation AtLoc,
6854	SourceLocation SelLoc,
6855	SourceLocation LParenLoc,
6856	SourceLocation RParenLoc,
6857	bool WarnMultipleSelectors);
6858
6859	/// ParseObjCProtocolExpression - Build protocol expression for \@protocol
6860	ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
6861	SourceLocation AtLoc,
6862	SourceLocation ProtoLoc,
6863	SourceLocation LParenLoc,
6864	SourceLocation ProtoIdLoc,
6865	SourceLocation RParenLoc);
6866
6867	//===--------------------------------------------------------------------===//
6868	// C++ Declarations
6869	//
6870	Decl ActOnStartLinkageSpecification(Scope S,
6871	SourceLocation ExternLoc,
6872	Expr *LangStr,
6873	SourceLocation LBraceLoc);
6874	Decl ActOnFinishLinkageSpecification(Scope S,
6875	Decl *LinkageSpec,
6876	SourceLocation RBraceLoc);
6877
6878
6879	//===--------------------------------------------------------------------===//
6880	// C++ Classes
6881	//
6882	CXXRecordDecl getCurrentClass(Scope S, const CXXScopeSpec *SS);
6883	bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
6884	const CXXScopeSpec SS = nullptr*);
6885	bool isCurrentClassNameTypo(IdentifierInfo &II, const* CXXScopeSpec *SS);
6886
6887	bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc,
6888	SourceLocation ColonLoc,
6889	const ParsedAttributesView &Attrs);
6890
6891	NamedDecl ActOnCXXMemberDeclarator(Scope S, AccessSpecifier AS,
6892	Declarator &D,
6893	MultiTemplateParamsArg TemplateParameterLists,
6894	Expr BitfieldWidth, const* VirtSpecifiers &VS,
6895	InClassInitStyle InitStyle);
6896
6897	void ActOnStartCXXInClassMemberInitializer();
6898	void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl,
6899	SourceLocation EqualLoc,
6900	Expr *Init);
6901
6902	MemInitResult ActOnMemInitializer(Decl *ConstructorD,
6903	Scope *S,
6904	CXXScopeSpec &SS,
6905	IdentifierInfo *MemberOrBase,
6906	ParsedType TemplateTypeTy,
6907	const DeclSpec &DS,
6908	SourceLocation IdLoc,
6909	SourceLocation LParenLoc,
6910	ArrayRef<Expr *> Args,
6911	SourceLocation RParenLoc,
6912	SourceLocation EllipsisLoc);
6913
6914	MemInitResult ActOnMemInitializer(Decl *ConstructorD,
6915	Scope *S,
6916	CXXScopeSpec &SS,
6917	IdentifierInfo *MemberOrBase,
6918	ParsedType TemplateTypeTy,
6919	const DeclSpec &DS,
6920	SourceLocation IdLoc,
6921	Expr *InitList,
6922	SourceLocation EllipsisLoc);
6923
6924	MemInitResult BuildMemInitializer(Decl *ConstructorD,
6925	Scope *S,
6926	CXXScopeSpec &SS,
6927	IdentifierInfo *MemberOrBase,
6928	ParsedType TemplateTypeTy,
6929	const DeclSpec &DS,
6930	SourceLocation IdLoc,
6931	Expr *Init,
6932	SourceLocation EllipsisLoc);
6933
6934	MemInitResult BuildMemberInitializer(ValueDecl *Member,
6935	Expr *Init,
6936	SourceLocation IdLoc);
6937
6938	MemInitResult BuildBaseInitializer(QualType BaseType,
6939	TypeSourceInfo *BaseTInfo,
6940	Expr *Init,
6941	CXXRecordDecl *ClassDecl,
6942	SourceLocation EllipsisLoc);
6943
6944	MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo,
6945	Expr *Init,
6946	CXXRecordDecl *ClassDecl);
6947
6948	bool SetDelegatingInitializer(CXXConstructorDecl *Constructor,
6949	CXXCtorInitializer *Initializer);
6950
6951	bool SetCtorInitializers(CXXConstructorDecl Constructor, bool* AnyErrors,
6952	ArrayRef<CXXCtorInitializer *> Initializers = None);
6953
6954	void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation);
6955
6956
6957	/// MarkBaseAndMemberDestructorsReferenced - Given a record decl,
6958	/// mark all the non-trivial destructors of its members and bases as
6959	/// referenced.
6960	void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc,
6961	CXXRecordDecl *Record);
6962
6963	/// Mark destructors of virtual bases of this class referenced. In the Itanium
6964	/// C++ ABI, this is done when emitting a destructor for any non-abstract
6965	/// class. In the Microsoft C++ ABI, this is done any time a class's
6966	/// destructor is referenced.
6967	void MarkVirtualBaseDestructorsReferenced(
6968	SourceLocation Location, CXXRecordDecl *ClassDecl,
6969	llvm::SmallPtrSetImpl<const RecordType > DirectVirtualBases = nullptr);
6970
6971	/// Do semantic checks to allow the complete destructor variant to be emitted
6972	/// when the destructor is defined in another translation unit. In the Itanium
6973	/// C++ ABI, destructor variants are emitted together. In the MS C++ ABI, they
6974	/// can be emitted in separate TUs. To emit the complete variant, run a subset
6975	/// of the checks performed when emitting a regular destructor.
6976	void CheckCompleteDestructorVariant(SourceLocation CurrentLocation,
6977	CXXDestructorDecl *Dtor);
6978
6979	/// The list of classes whose vtables have been used within
6980	/// this translation unit, and the source locations at which the
6981	/// first use occurred.
6982	typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse;
6983
6984	/// The list of vtables that are required but have not yet been
6985	/// materialized.
6986	SmallVector<VTableUse, `16`> VTableUses;
6987
6988	/// The set of classes whose vtables have been used within
6989	/// this translation unit, and a bit that will be true if the vtable is
6990	/// required to be emitted (otherwise, it should be emitted only if needed
6991	/// by code generation).
6992	llvm::DenseMap<CXXRecordDecl , bool*> VTablesUsed;
6993
6994	/// Load any externally-stored vtable uses.
6995	void LoadExternalVTableUses();
6996
6997	/// Note that the vtable for the given class was used at the
6998	/// given location.
6999	void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
7000	bool DefinitionRequired = false);
7001
7002	/// Mark the exception specifications of all virtual member functions
7003	/// in the given class as needed.
7004	void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
7005	const CXXRecordDecl *RD);
7006
7007	/// MarkVirtualMembersReferenced - Will mark all members of the given
7008	/// CXXRecordDecl referenced.
7009	void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD,
7010	bool ConstexprOnly = false);
7011
7012	/// Define all of the vtables that have been used in this
7013	/// translation unit and reference any virtual members used by those
7014	/// vtables.
7015	///
7016	/// \returns true if any work was done, false otherwise.
7017	bool DefineUsedVTables();
7018
7019	void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
7020
7021	void ActOnMemInitializers(Decl *ConstructorDecl,
7022	SourceLocation ColonLoc,
7023	ArrayRef<CXXCtorInitializer*> MemInits,
7024	bool AnyErrors);
7025
7026	/// Check class-level dllimport/dllexport attribute. The caller must
7027	/// ensure that referenceDLLExportedClassMethods is called some point later
7028	/// when all outer classes of Class are complete.
7029	void checkClassLevelDLLAttribute(CXXRecordDecl *Class);
7030	void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class);
7031
7032	void referenceDLLExportedClassMethods();
7033
7034	void propagateDLLAttrToBaseClassTemplate(
7035	CXXRecordDecl Class, Attr ClassAttr,
7036	ClassTemplateSpecializationDecl *BaseTemplateSpec,
7037	SourceLocation BaseLoc);
7038
7039	/// Add gsl::Pointer attribute to std::container::iterator
7040	/// \param ND The declaration that introduces the name
7041	/// std::container::iterator. \param UnderlyingRecord The record named by ND.
7042	void inferGslPointerAttribute(NamedDecl ND, CXXRecordDecl UnderlyingRecord);
7043
7044	/// Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
7045	void inferGslOwnerPointerAttribute(CXXRecordDecl *Record);
7046
7047	/// Add [[gsl::Pointer]] attributes for std:: types.
7048	void inferGslPointerAttribute(TypedefNameDecl *TD);
7049
7050	void CheckCompletedCXXClass(Scope S, CXXRecordDecl Record);
7051
7052	/// Check that the C++ class annoated with "trivial_abi" satisfies all the
7053	/// conditions that are needed for the attribute to have an effect.
7054	void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD);
7055
7056	void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc,
7057	Decl *TagDecl, SourceLocation LBrac,
7058	SourceLocation RBrac,
7059	const ParsedAttributesView &AttrList);
7060	void ActOnFinishCXXMemberDecls();
7061	void ActOnFinishCXXNonNestedClass();
7062
7063	void ActOnReenterCXXMethodParameter(Scope S, ParmVarDecl Param);
7064	unsigned ActOnReenterTemplateScope(Decl *Template,
7065	llvm::function_ref<Scope *()> EnterScope);
7066	void ActOnStartDelayedMemberDeclarations(Scope S, Decl Record);
7067	void ActOnStartDelayedCXXMethodDeclaration(Scope S, Decl Method);
7068	void ActOnDelayedCXXMethodParameter(Scope S, Decl Param);
7069	void ActOnFinishDelayedMemberDeclarations(Scope S, Decl Record);
7070	void ActOnFinishDelayedCXXMethodDeclaration(Scope S, Decl Method);
7071	void ActOnFinishDelayedMemberInitializers(Decl *Record);
7072	void MarkAsLateParsedTemplate(FunctionDecl FD, Decl FnD,
7073	CachedTokens &Toks);
7074	void UnmarkAsLateParsedTemplate(FunctionDecl *FD);
7075	bool IsInsideALocalClassWithinATemplateFunction();
7076
7077	Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
7078	Expr *AssertExpr,
7079	Expr *AssertMessageExpr,
7080	SourceLocation RParenLoc);
7081	Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
7082	Expr *AssertExpr,
7083	StringLiteral *AssertMessageExpr,
7084	SourceLocation RParenLoc,
7085	bool Failed);
7086
7087	FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart,
7088	SourceLocation FriendLoc,
7089	TypeSourceInfo *TSInfo);
7090	Decl ActOnFriendTypeDecl(Scope S, const DeclSpec &DS,
7091	MultiTemplateParamsArg TemplateParams);
7092	NamedDecl ActOnFriendFunctionDecl(Scope S, Declarator &D,
7093	MultiTemplateParamsArg TemplateParams);
7094
7095	QualType CheckConstructorDeclarator(Declarator &D, QualType R,
7096	StorageClass& SC);
7097	void CheckConstructor(CXXConstructorDecl *Constructor);
7098	QualType CheckDestructorDeclarator(Declarator &D, QualType R,
7099	StorageClass& SC);
7100	bool CheckDestructor(CXXDestructorDecl *Destructor);
7101	void CheckConversionDeclarator(Declarator &D, QualType &R,
7102	StorageClass& SC);
7103	Decl ActOnConversionDeclarator(CXXConversionDecl Conversion);
7104	void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
7105	StorageClass &SC);
7106	void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);
7107
7108	void CheckExplicitlyDefaultedFunction(Scope S, FunctionDecl MD);
7109
7110	bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,
7111	CXXSpecialMember CSM);
7112	void CheckDelayedMemberExceptionSpecs();
7113
7114	bool CheckExplicitlyDefaultedComparison(Scope S, FunctionDecl MD,
7115	DefaultedComparisonKind DCK);
7116	void DeclareImplicitEqualityComparison(CXXRecordDecl *RD,
7117	FunctionDecl *Spaceship);
7118	void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD,
7119	DefaultedComparisonKind DCK);
7120
7121	//===--------------------------------------------------------------------===//
7122	// C++ Derived Classes
7123	//
7124
7125	/// ActOnBaseSpecifier - Parsed a base specifier
7126	CXXBaseSpecifier CheckBaseSpecifier(CXXRecordDecl Class,
7127	SourceRange SpecifierRange,
7128	bool Virtual, AccessSpecifier Access,
7129	TypeSourceInfo *TInfo,
7130	SourceLocation EllipsisLoc);
7131
7132	BaseResult ActOnBaseSpecifier(Decl *classdecl,
7133	SourceRange SpecifierRange,
7134	ParsedAttributes &Attrs,
7135	bool Virtual, AccessSpecifier Access,
7136	ParsedType basetype,
7137	SourceLocation BaseLoc,
7138	SourceLocation EllipsisLoc);
7139
7140	bool AttachBaseSpecifiers(CXXRecordDecl *Class,
7141	MutableArrayRef<CXXBaseSpecifier *> Bases);
7142	void ActOnBaseSpecifiers(Decl *ClassDecl,
7143	MutableArrayRef<CXXBaseSpecifier *> Bases);
7144
7145	bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);
7146	bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
7147	CXXBasePaths &Paths);
7148
7149	// FIXME: I don't like this name.
7150	void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath);
7151
7152	bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
7153	SourceLocation Loc, SourceRange Range,
7154	CXXCastPath BasePath = nullptr*,
7155	bool IgnoreAccess = false);
7156	bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
7157	unsigned InaccessibleBaseID,
7158	unsigned AmbiguousBaseConvID,
7159	SourceLocation Loc, SourceRange Range,
7160	DeclarationName Name,
7161	CXXCastPath *BasePath,
7162	bool IgnoreAccess = false);
7163
7164	std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);
7165
7166	bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
7167	const CXXMethodDecl *Old);
7168
7169	/// CheckOverridingFunctionReturnType - Checks whether the return types are
7170	/// covariant, according to C++ [class.virtual]p5.
7171	bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
7172	const CXXMethodDecl *Old);
7173
7174	/// CheckOverridingFunctionExceptionSpec - Checks whether the exception
7175	/// spec is a subset of base spec.
7176	bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
7177	const CXXMethodDecl *Old);
7178
7179	bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);
7180
7181	/// CheckOverrideControl - Check C++11 override control semantics.
7182	void CheckOverrideControl(NamedDecl *D);
7183
7184	/// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was
7185	/// not used in the declaration of an overriding method.
7186	void DiagnoseAbsenceOfOverrideControl(NamedDecl D, bool* Inconsistent);
7187
7188	/// CheckForFunctionMarkedFinal - Checks whether a virtual member function
7189	/// overrides a virtual member function marked 'final', according to
7190	/// C++11 [class.virtual]p4.
7191	bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
7192	const CXXMethodDecl *Old);
7193
7194
7195	//===--------------------------------------------------------------------===//
7196	// C++ Access Control
7197	//
7198
7199	enum AccessResult {
7200	AR_accessible,
7201	AR_inaccessible,
7202	AR_dependent,
7203	AR_delayed
7204	};
7205
7206	bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
7207	NamedDecl *PrevMemberDecl,
7208	AccessSpecifier LexicalAS);
7209
7210	AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
7211	DeclAccessPair FoundDecl);
7212	AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
7213	DeclAccessPair FoundDecl);
7214	AccessResult CheckAllocationAccess(SourceLocation OperatorLoc,
7215	SourceRange PlacementRange,
7216	CXXRecordDecl *NamingClass,
7217	DeclAccessPair FoundDecl,
7218	bool Diagnose = true);
7219	AccessResult CheckConstructorAccess(SourceLocation Loc,
7220	CXXConstructorDecl *D,
7221	DeclAccessPair FoundDecl,
7222	const InitializedEntity &Entity,
7223	bool IsCopyBindingRefToTemp = false);
7224	AccessResult CheckConstructorAccess(SourceLocation Loc,
7225	CXXConstructorDecl *D,
7226	DeclAccessPair FoundDecl,
7227	const InitializedEntity &Entity,
7228	const PartialDiagnostic &PDiag);
7229	AccessResult CheckDestructorAccess(SourceLocation Loc,
7230	CXXDestructorDecl *Dtor,
7231	const PartialDiagnostic &PDiag,
7232	QualType objectType = QualType ());
7233	AccessResult CheckFriendAccess(NamedDecl *D);
7234	AccessResult CheckMemberAccess(SourceLocation UseLoc,
7235	CXXRecordDecl *NamingClass,
7236	DeclAccessPair Found);
7237	AccessResult
7238	CheckStructuredBindingMemberAccess(SourceLocation UseLoc,
7239	CXXRecordDecl *DecomposedClass,
7240	DeclAccessPair Field);
7241	AccessResult CheckMemberOperatorAccess(SourceLocation Loc,
7242	Expr *ObjectExpr,
7243	Expr *ArgExpr,
7244	DeclAccessPair FoundDecl);
7245	AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,
7246	DeclAccessPair FoundDecl);
7247	AccessResult CheckBaseClassAccess(SourceLocation AccessLoc,
7248	QualType Base, QualType Derived,
7249	const CXXBasePath &Path,
7250	unsigned DiagID,
7251	bool ForceCheck = false,
7252	bool ForceUnprivileged = false);
7253	void CheckLookupAccess(const LookupResult &R);
7254	bool IsSimplyAccessible(NamedDecl Decl, CXXRecordDecl NamingClass,
7255	QualType BaseType);
7256	bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
7257	DeclAccessPair Found, QualType ObjectType,
7258	SourceLocation Loc,
7259	const PartialDiagnostic &Diag);
7260	bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
7261	DeclAccessPair Found,
7262	QualType ObjectType) {
7263	return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType,
7264	SourceLocation (), PDiag());
7265	}
7266
7267	void HandleDependentAccessCheck(const DependentDiagnostic &DD,
7268	const MultiLevelTemplateArgumentList &TemplateArgs);
7269	void PerformDependentDiagnostics(const DeclContext *Pattern,
7270	const MultiLevelTemplateArgumentList &TemplateArgs);
7271
7272	void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
7273
7274	/// When true, access checking violations are treated as SFINAE
7275	/// failures rather than hard errors.
7276	bool AccessCheckingSFINAE;
7277
7278	enum AbstractDiagSelID {
7279	AbstractNone = -`1`,
7280	AbstractReturnType,
7281	AbstractParamType,
7282	AbstractVariableType,
7283	AbstractFieldType,
7284	AbstractIvarType,
7285	AbstractSynthesizedIvarType,
7286	AbstractArrayType
7287	};
7288
7289	bool isAbstractType(SourceLocation Loc, QualType T);
7290	bool RequireNonAbstractType(SourceLocation Loc, QualType T,
7291	TypeDiagnoser &Diagnoser);
7292	template <typename... Ts>
7293	bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
7294	const Ts &...Args) {
7295	BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
7296	return RequireNonAbstractType(Loc, T, Diagnoser);
7297	}
7298
7299	void DiagnoseAbstractType(const CXXRecordDecl *RD);
7300
7301	//===--------------------------------------------------------------------===//
7302	// C++ Overloaded Operators [C++ 13.5]
7303	//
7304
7305	bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
7306
7307	bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl);
7308
7309	//===--------------------------------------------------------------------===//
7310	// C++ Templates [C++ 14]
7311	//
7312	void FilterAcceptableTemplateNames(LookupResult &R,
7313	bool AllowFunctionTemplates = true,
7314	bool AllowDependent = true);
7315	bool hasAnyAcceptableTemplateNames(LookupResult &R,
7316	bool AllowFunctionTemplates = true,
7317	bool AllowDependent = true,
7318	bool AllowNonTemplateFunctions = false);
7319	/// Try to interpret the lookup result D as a template-name.
7320	///
7321	/// \param D A declaration found by name lookup.
7322	/// \param AllowFunctionTemplates Whether function templates should be
7323	/// considered valid results.
7324	/// \param AllowDependent Whether unresolved using declarations (that might
7325	/// name templates) should be considered valid results.
7326	static NamedDecl getAsTemplateNameDecl(NamedDecl D,
7327	bool AllowFunctionTemplates = true,
7328	bool AllowDependent = true);
7329
7330	enum TemplateNameIsRequiredTag { TemplateNameIsRequired };
7331	/// Whether and why a template name is required in this lookup.
7332	class RequiredTemplateKind {
7333	public:
7334	/// Template name is required if TemplateKWLoc is valid.
7335	RequiredTemplateKind(SourceLocation TemplateKWLoc = SourceLocation ())
7336	: TemplateKW (TemplateKWLoc) {}
7337	/// Template name is unconditionally required.
7338	RequiredTemplateKind(TemplateNameIsRequiredTag) : TemplateKW () {}
7339
7340	SourceLocation getTemplateKeywordLoc() const {
7341	return TemplateKW.getValueOr(SourceLocation ());
7342	}
7343	bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
7344	bool isRequired() const { return TemplateKW != SourceLocation (); }
7345	explicit operator bool() const { return isRequired(); }
7346
7347	private:
7348	llvm::Optional<SourceLocation> TemplateKW;
7349	};
7350
7351	enum class AssumedTemplateKind {
7352	/// This is not assumed to be a template name.
7353	None,
7354	/// This is assumed to be a template name because lookup found nothing.
7355	FoundNothing,
7356	/// This is assumed to be a template name because lookup found one or more
7357	/// functions (but no function templates).
7358	FoundFunctions,
7359	};
7360	bool LookupTemplateName(
7361	LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType,
7362	bool EnteringContext, bool &MemberOfUnknownSpecialization,
7363	RequiredTemplateKind RequiredTemplate = SourceLocation (),
7364	AssumedTemplateKind ATK = nullptr, bool* AllowTypoCorrection = true);
7365
7366	TemplateNameKind isTemplateName(Scope *S,
7367	CXXScopeSpec &SS,
7368	bool hasTemplateKeyword,
7369	const UnqualifiedId &Name,
7370	ParsedType ObjectType,
7371	bool EnteringContext,
7372	TemplateTy &Template,
7373	bool &MemberOfUnknownSpecialization,
7374	bool Disambiguation = false);
7375
7376	/// Try to resolve an undeclared template name as a type template.
7377	///
7378	/// Sets II to the identifier corresponding to the template name, and updates
7379	/// Name to a corresponding (typo-corrected) type template name and TNK to
7380	/// the corresponding kind, if possible.
7381	void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name,
7382	TemplateNameKind &TNK,
7383	SourceLocation NameLoc,
7384	IdentifierInfo *&II);
7385
7386	bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,
7387	SourceLocation NameLoc,
7388	bool Diagnose = true);
7389
7390	/// Determine whether a particular identifier might be the name in a C++1z
7391	/// deduction-guide declaration.
7392	bool isDeductionGuideName(Scope S, const* IdentifierInfo &Name,
7393	SourceLocation NameLoc,
7394	ParsedTemplateTy Template = nullptr*);
7395
7396	bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
7397	SourceLocation IILoc,
7398	Scope *S,
7399	const CXXScopeSpec *SS,
7400	TemplateTy &SuggestedTemplate,
7401	TemplateNameKind &SuggestedKind);
7402
7403	bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
7404	NamedDecl *Instantiation,
7405	bool InstantiatedFromMember,
7406	const NamedDecl *Pattern,
7407	const NamedDecl *PatternDef,
7408	TemplateSpecializationKind TSK,
7409	bool Complain = true);
7410
7411	void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
7412	TemplateDecl AdjustDeclIfTemplate(Decl &Decl);
7413
7414	NamedDecl ActOnTypeParameter(Scope S, bool Typename,
7415	SourceLocation EllipsisLoc,
7416	SourceLocation KeyLoc,
7417	IdentifierInfo *ParamName,
7418	SourceLocation ParamNameLoc,
7419	unsigned Depth, unsigned Position,
7420	SourceLocation EqualLoc,
7421	ParsedType DefaultArg, bool HasTypeConstraint);
7422
7423	bool ActOnTypeConstraint(const CXXScopeSpec &SS,
7424	TemplateIdAnnotation *TypeConstraint,
7425	TemplateTypeParmDecl *ConstrainedParameter,
7426	SourceLocation EllipsisLoc);
7427
7428	bool AttachTypeConstraint(NestedNameSpecifierLoc NS,
7429	DeclarationNameInfo NameInfo,
7430	ConceptDecl *NamedConcept,
7431	const TemplateArgumentListInfo *TemplateArgs,
7432	TemplateTypeParmDecl *ConstrainedParameter,
7433	SourceLocation EllipsisLoc);
7434
7435	bool AttachTypeConstraint(AutoTypeLoc TL,
7436	NonTypeTemplateParmDecl *ConstrainedParameter,
7437	SourceLocation EllipsisLoc);
7438
7439	bool RequireStructuralType(QualType T, SourceLocation Loc);
7440
7441	QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
7442	SourceLocation Loc);
7443	QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
7444
7445	NamedDecl ActOnNonTypeTemplateParameter(Scope S, Declarator &D,
7446	unsigned Depth,
7447	unsigned Position,
7448	SourceLocation EqualLoc,
7449	Expr *DefaultArg);
7450	NamedDecl ActOnTemplateTemplateParameter(Scope S,
7451	SourceLocation TmpLoc,
7452	TemplateParameterList *Params,
7453	SourceLocation EllipsisLoc,
7454	IdentifierInfo *ParamName,
7455	SourceLocation ParamNameLoc,
7456	unsigned Depth,
7457	unsigned Position,
7458	SourceLocation EqualLoc,
7459	ParsedTemplateArgument DefaultArg);
7460
7461	TemplateParameterList *
7462	ActOnTemplateParameterList(unsigned Depth,
7463	SourceLocation ExportLoc,
7464	SourceLocation TemplateLoc,
7465	SourceLocation LAngleLoc,
7466	ArrayRef<NamedDecl *> Params,
7467	SourceLocation RAngleLoc,
7468	Expr *RequiresClause);
7469
7470	/// The context in which we are checking a template parameter list.
7471	enum TemplateParamListContext {
7472	TPC_ClassTemplate,
7473	TPC_VarTemplate,
7474	TPC_FunctionTemplate,
7475	TPC_ClassTemplateMember,
7476	TPC_FriendClassTemplate,
7477	TPC_FriendFunctionTemplate,
7478	TPC_FriendFunctionTemplateDefinition,
7479	TPC_TypeAliasTemplate
7480	};
7481
7482	bool CheckTemplateParameterList(TemplateParameterList *NewParams,
7483	TemplateParameterList *OldParams,
7484	TemplateParamListContext TPC,
7485	SkipBodyInfo SkipBody = nullptr*);
7486	TemplateParameterList *MatchTemplateParametersToScopeSpecifier(
7487	SourceLocation DeclStartLoc, SourceLocation DeclLoc,
7488	const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId,
7489	ArrayRef<TemplateParameterList *> ParamLists,
7490	bool IsFriend, bool &IsMemberSpecialization, bool &Invalid,
7491	bool SuppressDiagnostic = false);
7492
7493	DeclResult CheckClassTemplate(
7494	Scope S, unsigned* TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7495	CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
7496	const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
7497	AccessSpecifier AS, SourceLocation ModulePrivateLoc,
7498	SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
7499	TemplateParameterList **OuterTemplateParamLists,
7500	SkipBodyInfo SkipBody = nullptr*);
7501
7502	TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
7503	QualType NTTPType,
7504	SourceLocation Loc);
7505
7506	/// Get a template argument mapping the given template parameter to itself,
7507	/// e.g. for X in \c template<int X>, this would return an expression template
7508	/// argument referencing X.
7509	TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param,
7510	SourceLocation Location);
7511
7512	void translateTemplateArguments(const ASTTemplateArgsPtr &In,
7513	TemplateArgumentListInfo &Out);
7514
7515	ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType);
7516
7517	void NoteAllFoundTemplates(TemplateName Name);
7518
7519	QualType CheckTemplateIdType(TemplateName Template,
7520	SourceLocation TemplateLoc,
7521	TemplateArgumentListInfo &TemplateArgs);
7522
7523	TypeResult
7524	ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
7525	TemplateTy Template, IdentifierInfo *TemplateII,
7526	SourceLocation TemplateIILoc, SourceLocation LAngleLoc,
7527	ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc,
7528	bool IsCtorOrDtorName = false, bool IsClassName = false);
7529
7530	/// Parsed an elaborated-type-specifier that refers to a template-id,
7531	/// such as \c class T::template apply<U>.
7532	TypeResult ActOnTagTemplateIdType(TagUseKind TUK,
7533	TypeSpecifierType TagSpec,
7534	SourceLocation TagLoc,
7535	CXXScopeSpec &SS,
7536	SourceLocation TemplateKWLoc,
7537	TemplateTy TemplateD,
7538	SourceLocation TemplateLoc,
7539	SourceLocation LAngleLoc,
7540	ASTTemplateArgsPtr TemplateArgsIn,
7541	SourceLocation RAngleLoc);
7542
7543	DeclResult ActOnVarTemplateSpecialization(
7544	Scope S, Declarator &D, TypeSourceInfo DI,
7545	SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
7546	StorageClass SC, bool IsPartialSpecialization);
7547
7548	/// Get the specialization of the given variable template corresponding to
7549	/// the specified argument list, or a null-but-valid result if the arguments
7550	/// are dependent.
7551	DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
7552	SourceLocation TemplateLoc,
7553	SourceLocation TemplateNameLoc,
7554	const TemplateArgumentListInfo &TemplateArgs);
7555
7556	/// Form a reference to the specialization of the given variable template
7557	/// corresponding to the specified argument list, or a null-but-valid result
7558	/// if the arguments are dependent.
7559	ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,
7560	const DeclarationNameInfo &NameInfo,
7561	VarTemplateDecl *Template,
7562	SourceLocation TemplateLoc,
7563	const TemplateArgumentListInfo *TemplateArgs);
7564
7565	ExprResult
7566	CheckConceptTemplateId(const CXXScopeSpec &SS,
7567	SourceLocation TemplateKWLoc,
7568	const DeclarationNameInfo &ConceptNameInfo,
7569	NamedDecl FoundDecl, ConceptDecl NamedConcept,
7570	const TemplateArgumentListInfo *TemplateArgs);
7571
7572	void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc);
7573
7574	ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
7575	SourceLocation TemplateKWLoc,
7576	LookupResult &R,
7577	bool RequiresADL,
7578	const TemplateArgumentListInfo *TemplateArgs);
7579
7580	ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
7581	SourceLocation TemplateKWLoc,
7582	const DeclarationNameInfo &NameInfo,
7583	const TemplateArgumentListInfo *TemplateArgs);
7584
7585	TemplateNameKind ActOnTemplateName(
7586	Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
7587	const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext,
7588	TemplateTy &Template, bool AllowInjectedClassName = false);
7589
7590	DeclResult ActOnClassTemplateSpecialization(
7591	Scope S, unsigned* TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7592	SourceLocation ModulePrivateLoc, CXXScopeSpec &SS,
7593	TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr,
7594	MultiTemplateParamsArg TemplateParameterLists,
7595	SkipBodyInfo SkipBody = nullptr*);
7596
7597	bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc,
7598	TemplateDecl *PrimaryTemplate,
7599	unsigned NumExplicitArgs,
7600	ArrayRef<TemplateArgument> Args);
7601	void CheckTemplatePartialSpecialization(
7602	ClassTemplatePartialSpecializationDecl *Partial);
7603	void CheckTemplatePartialSpecialization(
7604	VarTemplatePartialSpecializationDecl *Partial);
7605
7606	Decl ActOnTemplateDeclarator(Scope S,
7607	MultiTemplateParamsArg TemplateParameterLists,
7608	Declarator &D);
7609
7610	bool
7611	CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
7612	TemplateSpecializationKind NewTSK,
7613	NamedDecl *PrevDecl,
7614	TemplateSpecializationKind PrevTSK,
7615	SourceLocation PrevPtOfInstantiation,
7616	bool &SuppressNew);
7617
7618	bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
7619	const TemplateArgumentListInfo &ExplicitTemplateArgs,
7620	LookupResult &Previous);
7621
7622	bool CheckFunctionTemplateSpecialization(
7623	FunctionDecl FD, TemplateArgumentListInfo ExplicitTemplateArgs,
7624	LookupResult &Previous, bool QualifiedFriend = false);
7625	bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
7626	void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
7627
7628	DeclResult ActOnExplicitInstantiation(
7629	Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
7630	unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
7631	TemplateTy Template, SourceLocation TemplateNameLoc,
7632	SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs,
7633	SourceLocation RAngleLoc, const ParsedAttributesView &Attr);
7634
7635	DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,
7636	SourceLocation TemplateLoc,
7637	unsigned TagSpec, SourceLocation KWLoc,
7638	CXXScopeSpec &SS, IdentifierInfo *Name,
7639	SourceLocation NameLoc,
7640	const ParsedAttributesView &Attr);
7641
7642	DeclResult ActOnExplicitInstantiation(Scope *S,
7643	SourceLocation ExternLoc,
7644	SourceLocation TemplateLoc,
7645	Declarator &D);
7646
7647	TemplateArgumentLoc
7648	SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
7649	SourceLocation TemplateLoc,
7650	SourceLocation RAngleLoc,
7651	Decl *Param,
7652	SmallVectorImpl<TemplateArgument>
7653	&Converted,
7654	bool &HasDefaultArg);
7655
7656	/// Specifies the context in which a particular template
7657	/// argument is being checked.
7658	enum CheckTemplateArgumentKind {
7659	/// The template argument was specified in the code or was
7660	/// instantiated with some deduced template arguments.
7661	CTAK_Specified,
7662
7663	/// The template argument was deduced via template argument
7664	/// deduction.
7665	CTAK_Deduced,
7666
7667	/// The template argument was deduced from an array bound
7668	/// via template argument deduction.
7669	CTAK_DeducedFromArrayBound
7670	};
7671
7672	bool CheckTemplateArgument(NamedDecl *Param,
7673	TemplateArgumentLoc &Arg,
7674	NamedDecl *Template,
7675	SourceLocation TemplateLoc,
7676	SourceLocation RAngleLoc,
7677	unsigned ArgumentPackIndex,
7678	SmallVectorImpl<TemplateArgument> &Converted,
7679	CheckTemplateArgumentKind CTAK = CTAK_Specified);
7680
7681	/// Check that the given template arguments can be be provided to
7682	/// the given template, converting the arguments along the way.
7683	///
7684	/// \param Template The template to which the template arguments are being
7685	/// provided.
7686	///
7687	/// \param TemplateLoc The location of the template name in the source.
7688	///
7689	/// \param TemplateArgs The list of template arguments. If the template is
7690	/// a template template parameter, this function may extend the set of
7691	/// template arguments to also include substituted, defaulted template
7692	/// arguments.
7693	///
7694	/// \param PartialTemplateArgs True if the list of template arguments is
7695	/// intentionally partial, e.g., because we're checking just the initial
7696	/// set of template arguments.
7697	///
7698	/// \param Converted Will receive the converted, canonicalized template
7699	/// arguments.
7700	///
7701	/// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to
7702	/// contain the converted forms of the template arguments as written.
7703	/// Otherwise, \p TemplateArgs will not be modified.
7704	///
7705	/// \param ConstraintsNotSatisfied If provided, and an error occured, will
7706	/// receive true if the cause for the error is the associated constraints of
7707	/// the template not being satisfied by the template arguments.
7708	///
7709	/// \returns true if an error occurred, false otherwise.
7710	bool CheckTemplateArgumentList(TemplateDecl *Template,
7711	SourceLocation TemplateLoc,
7712	TemplateArgumentListInfo &TemplateArgs,
7713	bool PartialTemplateArgs,
7714	SmallVectorImpl<TemplateArgument> &Converted,
7715	bool UpdateArgsWithConversions = true,
7716	bool ConstraintsNotSatisfied = nullptr*);
7717
7718	bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
7719	TemplateArgumentLoc &Arg,
7720	SmallVectorImpl<TemplateArgument> &Converted);
7721
7722	bool CheckTemplateArgument(TemplateTypeParmDecl *Param,
7723	TypeSourceInfo *Arg);
7724	ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
7725	QualType InstantiatedParamType, Expr *Arg,
7726	TemplateArgument &Converted,
7727	CheckTemplateArgumentKind CTAK = CTAK_Specified);
7728	bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
7729	TemplateParameterList *Params,
7730	TemplateArgumentLoc &Arg);
7731
7732	ExprResult
7733	BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
7734	QualType ParamType,
7735	SourceLocation Loc);
7736	ExprResult
7737	BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
7738	SourceLocation Loc);
7739
7740	/// Enumeration describing how template parameter lists are compared
7741	/// for equality.
7742	enum TemplateParameterListEqualKind {
7743	/// We are matching the template parameter lists of two templates
7744	/// that might be redeclarations.
7745	///
7746	/// \code
7747	/// template<typename T> struct X;
7748	/// template<typename T> struct X;
7749	/// \endcode
7750	TPL_TemplateMatch,
7751
7752	/// We are matching the template parameter lists of two template
7753	/// template parameters as part of matching the template parameter lists
7754	/// of two templates that might be redeclarations.
7755	///
7756	/// \code
7757	/// template<template<int I> class TT> struct X;
7758	/// template<template<int Value> class Other> struct X;
7759	/// \endcode
7760	TPL_TemplateTemplateParmMatch,
7761
7762	/// We are matching the template parameter lists of a template
7763	/// template argument against the template parameter lists of a template
7764	/// template parameter.
7765	///
7766	/// \code
7767	/// template<template<int Value> class Metafun> struct X;
7768	/// template<int Value> struct integer_c;
7769	/// X<integer_c> xic;
7770	/// \endcode
7771	TPL_TemplateTemplateArgumentMatch
7772	};
7773
7774	bool TemplateParameterListsAreEqual(TemplateParameterList *New,
7775	TemplateParameterList *Old,
7776	bool Complain,
7777	TemplateParameterListEqualKind Kind,
7778	SourceLocation TemplateArgLoc
7779	= SourceLocation ());
7780
7781	bool CheckTemplateDeclScope(Scope S, TemplateParameterList TemplateParams);
7782
7783	/// Called when the parser has parsed a C++ typename
7784	/// specifier, e.g., "typename T::type".
7785	///
7786	/// \param S The scope in which this typename type occurs.
7787	/// \param TypenameLoc the location of the 'typename' keyword
7788	/// \param SS the nested-name-specifier following the typename (e.g., 'T::').
7789	/// \param II the identifier we're retrieving (e.g., 'type' in the example).
7790	/// \param IdLoc the location of the identifier.
7791	TypeResult
7792	ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
7793	const CXXScopeSpec &SS, const IdentifierInfo &II,
7794	SourceLocation IdLoc);
7795
7796	/// Called when the parser has parsed a C++ typename
7797	/// specifier that ends in a template-id, e.g.,
7798	/// "typename MetaFun::template apply<T1, T2>".
7799	///
7800	/// \param S The scope in which this typename type occurs.
7801	/// \param TypenameLoc the location of the 'typename' keyword
7802	/// \param SS the nested-name-specifier following the typename (e.g., 'T::').
7803	/// \param TemplateLoc the location of the 'template' keyword, if any.
7804	/// \param TemplateName The template name.
7805	/// \param TemplateII The identifier used to name the template.
7806	/// \param TemplateIILoc The location of the template name.
7807	/// \param LAngleLoc The location of the opening angle bracket ('<').
7808	/// \param TemplateArgs The template arguments.
7809	/// \param RAngleLoc The location of the closing angle bracket ('>').
7810	TypeResult
7811	ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
7812	const CXXScopeSpec &SS,
7813	SourceLocation TemplateLoc,
7814	TemplateTy TemplateName,
7815	IdentifierInfo *TemplateII,
7816	SourceLocation TemplateIILoc,
7817	SourceLocation LAngleLoc,
7818	ASTTemplateArgsPtr TemplateArgs,
7819	SourceLocation RAngleLoc);
7820
7821	QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
7822	SourceLocation KeywordLoc,
7823	NestedNameSpecifierLoc QualifierLoc,
7824	const IdentifierInfo &II,
7825	SourceLocation IILoc,
7826	TypeSourceInfo **TSI,
7827	bool DeducedTSTContext);
7828
7829	QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
7830	SourceLocation KeywordLoc,
7831	NestedNameSpecifierLoc QualifierLoc,
7832	const IdentifierInfo &II,
7833	SourceLocation IILoc,
7834	bool DeducedTSTContext = true);
7835
7836
7837	TypeSourceInfo RebuildTypeInCurrentInstantiation(TypeSourceInfo T,
7838	SourceLocation Loc,
7839	DeclarationName Name);
7840	bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS);
7841
7842	ExprResult RebuildExprInCurrentInstantiation(Expr *E);
7843	bool RebuildTemplateParamsInCurrentInstantiation(
7844	TemplateParameterList *Params);
7845
7846	std::string
7847	getTemplateArgumentBindingsText(const TemplateParameterList *Params,
7848	const TemplateArgumentList &Args);
7849
7850	std::string
7851	getTemplateArgumentBindingsText(const TemplateParameterList *Params,
7852	const TemplateArgument *Args,
7853	unsigned NumArgs);
7854
7855	//===--------------------------------------------------------------------===//
7856	// C++ Concepts
7857	//===--------------------------------------------------------------------===//
7858	Decl *ActOnConceptDefinition(
7859	Scope *S, MultiTemplateParamsArg TemplateParameterLists,
7860	IdentifierInfo Name, SourceLocation NameLoc, Expr ConstraintExpr);
7861
7862	RequiresExprBodyDecl *
7863	ActOnStartRequiresExpr(SourceLocation RequiresKWLoc,
7864	ArrayRef<ParmVarDecl *> LocalParameters,
7865	Scope *BodyScope);
7866	void ActOnFinishRequiresExpr();
7867	concepts::Requirement ActOnSimpleRequirement(Expr E);
7868	concepts::Requirement *ActOnTypeRequirement(
7869	SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc,
7870	IdentifierInfo TypeName, TemplateIdAnnotation TemplateId);
7871	concepts::Requirement ActOnCompoundRequirement(Expr E,
7872	SourceLocation NoexceptLoc);
7873	concepts::Requirement *
7874	ActOnCompoundRequirement(
7875	Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS,
7876	TemplateIdAnnotation TypeConstraint, unsigned* Depth);
7877	concepts::Requirement ActOnNestedRequirement(Expr Constraint);
7878	concepts::ExprRequirement *
7879	BuildExprRequirement(
7880	Expr E, bool* IsSatisfied, SourceLocation NoexceptLoc,
7881	concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);
7882	concepts::ExprRequirement *
7883	BuildExprRequirement(
7884	concepts::Requirement::SubstitutionDiagnostic *ExprSubstDiag,
7885	bool IsSatisfied, SourceLocation NoexceptLoc,
7886	concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);
7887	concepts::TypeRequirement BuildTypeRequirement(TypeSourceInfo Type);
7888	concepts::TypeRequirement *
7889	BuildTypeRequirement(
7890	concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
7891	concepts::NestedRequirement BuildNestedRequirement(Expr E);
7892	concepts::NestedRequirement *
7893	BuildNestedRequirement(
7894	concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
7895	ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc,
7896	RequiresExprBodyDecl *Body,
7897	ArrayRef<ParmVarDecl *> LocalParameters,
7898	ArrayRef<concepts::Requirement *> Requirements,
7899	SourceLocation ClosingBraceLoc);
7900
7901	//===--------------------------------------------------------------------===//
7902	// C++ Variadic Templates (C++0x [temp.variadic])
7903	//===--------------------------------------------------------------------===//
7904
7905	/// Determine whether an unexpanded parameter pack might be permitted in this
7906	/// location. Useful for error recovery.
7907	bool isUnexpandedParameterPackPermitted();
7908
7909	/// The context in which an unexpanded parameter pack is
7910	/// being diagnosed.
7911	///
7912	/// Note that the values of this enumeration line up with the first
7913	/// argument to the \c err_unexpanded_parameter_pack diagnostic.
7914	enum UnexpandedParameterPackContext {
7915	/// An arbitrary expression.
7916	UPPC_Expression = `0`,
7917
7918	/// The base type of a class type.
7919	UPPC_BaseType,
7920
7921	/// The type of an arbitrary declaration.
7922	UPPC_DeclarationType,
7923
7924	/// The type of a data member.
7925	UPPC_DataMemberType,
7926
7927	/// The size of a bit-field.
7928	UPPC_BitFieldWidth,
7929
7930	/// The expression in a static assertion.
7931	UPPC_StaticAssertExpression,
7932
7933	/// The fixed underlying type of an enumeration.
7934	UPPC_FixedUnderlyingType,
7935
7936	/// The enumerator value.
7937	UPPC_EnumeratorValue,
7938
7939	/// A using declaration.
7940	UPPC_UsingDeclaration,
7941
7942	/// A friend declaration.
7943	UPPC_FriendDeclaration,
7944
7945	/// A declaration qualifier.
7946	UPPC_DeclarationQualifier,
7947
7948	/// An initializer.
7949	UPPC_Initializer,
7950
7951	/// A default argument.
7952	UPPC_DefaultArgument,
7953
7954	/// The type of a non-type template parameter.
7955	UPPC_NonTypeTemplateParameterType,
7956
7957	/// The type of an exception.
7958	UPPC_ExceptionType,
7959
7960	/// Partial specialization.
7961	UPPC_PartialSpecialization,
7962
7963	/// Microsoft __if_exists.
7964	UPPC_IfExists,
7965
7966	/// Microsoft __if_not_exists.
7967	UPPC_IfNotExists,
7968
7969	/// Lambda expression.
7970	UPPC_Lambda,
7971
7972	/// Block expression.
7973	UPPC_Block,
7974
7975	/// A type constraint.
7976	UPPC_TypeConstraint,
7977
7978	// A requirement in a requires-expression.
7979	UPPC_Requirement,
7980
7981	// A requires-clause.
7982	UPPC_RequiresClause,
7983	};
7984
7985	/// Diagnose unexpanded parameter packs.
7986	///
7987	/// \param Loc The location at which we should emit the diagnostic.
7988	///
7989	/// \param UPPC The context in which we are diagnosing unexpanded
7990	/// parameter packs.
7991	///
7992	/// \param Unexpanded the set of unexpanded parameter packs.
7993	///
7994	/// \returns true if an error occurred, false otherwise.
7995	bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
7996	UnexpandedParameterPackContext UPPC,
7997	ArrayRef<UnexpandedParameterPack> Unexpanded);
7998
7999	/// If the given type contains an unexpanded parameter pack,
8000	/// diagnose the error.
8001	///
8002	/// \param Loc The source location where a diagnostc should be emitted.
8003	///
8004	/// \param T The type that is being checked for unexpanded parameter
8005	/// packs.
8006	///
8007	/// \returns true if an error occurred, false otherwise.
8008	bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T,
8009	UnexpandedParameterPackContext UPPC);
8010
8011	/// If the given expression contains an unexpanded parameter
8012	/// pack, diagnose the error.
8013	///
8014	/// \param E The expression that is being checked for unexpanded
8015	/// parameter packs.
8016	///
8017	/// \returns true if an error occurred, false otherwise.
8018	bool DiagnoseUnexpandedParameterPack(Expr *E,
8019	UnexpandedParameterPackContext UPPC = UPPC_Expression);
8020
8021	/// If the given requirees-expression contains an unexpanded reference to one
8022	/// of its own parameter packs, diagnose the error.
8023	///
8024	/// \param RE The requiress-expression that is being checked for unexpanded
8025	/// parameter packs.
8026	///
8027	/// \returns true if an error occurred, false otherwise.
8028	bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE);
8029
8030	/// If the given nested-name-specifier contains an unexpanded
8031	/// parameter pack, diagnose the error.
8032	///
8033	/// \param SS The nested-name-specifier that is being checked for
8034	/// unexpanded parameter packs.
8035	///
8036	/// \returns true if an error occurred, false otherwise.
8037	bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
8038	UnexpandedParameterPackContext UPPC);
8039
8040	/// If the given name contains an unexpanded parameter pack,
8041	/// diagnose the error.
8042	///
8043	/// \param NameInfo The name (with source location information) that
8044	/// is being checked for unexpanded parameter packs.
8045	///
8046	/// \returns true if an error occurred, false otherwise.
8047	bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
8048	UnexpandedParameterPackContext UPPC);
8049
8050	/// If the given template name contains an unexpanded parameter pack,
8051	/// diagnose the error.
8052	///
8053	/// \param Loc The location of the template name.
8054	///
8055	/// \param Template The template name that is being checked for unexpanded
8056	/// parameter packs.
8057	///
8058	/// \returns true if an error occurred, false otherwise.
8059	bool DiagnoseUnexpandedParameterPack(SourceLocation Loc,
8060	TemplateName Template,
8061	UnexpandedParameterPackContext UPPC);
8062
8063	/// If the given template argument contains an unexpanded parameter
8064	/// pack, diagnose the error.
8065	///
8066	/// \param Arg The template argument that is being checked for unexpanded
8067	/// parameter packs.
8068	///
8069	/// \returns true if an error occurred, false otherwise.
8070	bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
8071	UnexpandedParameterPackContext UPPC);
8072
8073	/// Collect the set of unexpanded parameter packs within the given
8074	/// template argument.
8075	///
8076	/// \param Arg The template argument that will be traversed to find
8077	/// unexpanded parameter packs.
8078	void collectUnexpandedParameterPacks(TemplateArgument Arg,
8079	SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8080
8081	/// Collect the set of unexpanded parameter packs within the given
8082	/// template argument.
8083	///
8084	/// \param Arg The template argument that will be traversed to find
8085	/// unexpanded parameter packs.
8086	void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
8087	SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8088
8089	/// Collect the set of unexpanded parameter packs within the given
8090	/// type.
8091	///
8092	/// \param T The type that will be traversed to find
8093	/// unexpanded parameter packs.
8094	void collectUnexpandedParameterPacks(QualType T,
8095	SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8096
8097	/// Collect the set of unexpanded parameter packs within the given
8098	/// type.
8099	///
8100	/// \param TL The type that will be traversed to find
8101	/// unexpanded parameter packs.
8102	void collectUnexpandedParameterPacks(TypeLoc TL,
8103	SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8104
8105	/// Collect the set of unexpanded parameter packs within the given
8106	/// nested-name-specifier.
8107	///
8108	/// \param NNS The nested-name-specifier that will be traversed to find
8109	/// unexpanded parameter packs.
8110	void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS,
8111	SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8112
8113	/// Collect the set of unexpanded parameter packs within the given
8114	/// name.
8115	///
8116	/// \param NameInfo The name that will be traversed to find
8117	/// unexpanded parameter packs.
8118	void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,
8119	SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8120
8121	/// Invoked when parsing a template argument followed by an
8122	/// ellipsis, which creates a pack expansion.
8123	///
8124	/// \param Arg The template argument preceding the ellipsis, which
8125	/// may already be invalid.
8126	///
8127	/// \param EllipsisLoc The location of the ellipsis.
8128	ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg,
8129	SourceLocation EllipsisLoc);
8130
8131	/// Invoked when parsing a type followed by an ellipsis, which
8132	/// creates a pack expansion.
8133	///
8134	/// \param Type The type preceding the ellipsis, which will become
8135	/// the pattern of the pack expansion.
8136	///
8137	/// \param EllipsisLoc The location of the ellipsis.
8138	TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc);
8139
8140	/// Construct a pack expansion type from the pattern of the pack
8141	/// expansion.
8142	TypeSourceInfo CheckPackExpansion(TypeSourceInfo Pattern,
8143	SourceLocation EllipsisLoc,
8144	Optional<unsigned> NumExpansions);
8145
8146	/// Construct a pack expansion type from the pattern of the pack
8147	/// expansion.
8148	QualType CheckPackExpansion(QualType Pattern,
8149	SourceRange PatternRange,
8150	SourceLocation EllipsisLoc,
8151	Optional<unsigned> NumExpansions);
8152
8153	/// Invoked when parsing an expression followed by an ellipsis, which
8154	/// creates a pack expansion.
8155	///
8156	/// \param Pattern The expression preceding the ellipsis, which will become
8157	/// the pattern of the pack expansion.
8158	///
8159	/// \param EllipsisLoc The location of the ellipsis.
8160	ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);
8161
8162	/// Invoked when parsing an expression followed by an ellipsis, which
8163	/// creates a pack expansion.
8164	///
8165	/// \param Pattern The expression preceding the ellipsis, which will become
8166	/// the pattern of the pack expansion.
8167	///
8168	/// \param EllipsisLoc The location of the ellipsis.
8169	ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
8170	Optional<unsigned> NumExpansions);
8171
8172	/// Determine whether we could expand a pack expansion with the
8173	/// given set of parameter packs into separate arguments by repeatedly
8174	/// transforming the pattern.
8175	///
8176	/// \param EllipsisLoc The location of the ellipsis that identifies the
8177	/// pack expansion.
8178	///
8179	/// \param PatternRange The source range that covers the entire pattern of
8180	/// the pack expansion.
8181	///
8182	/// \param Unexpanded The set of unexpanded parameter packs within the
8183	/// pattern.
8184	///
8185	/// \param ShouldExpand Will be set to \c true if the transformer should
8186	/// expand the corresponding pack expansions into separate arguments. When
8187	/// set, \c NumExpansions must also be set.
8188	///
8189	/// \param RetainExpansion Whether the caller should add an unexpanded
8190	/// pack expansion after all of the expanded arguments. This is used
8191	/// when extending explicitly-specified template argument packs per
8192	/// C++0x [temp.arg.explicit]p9.
8193	///
8194	/// \param NumExpansions The number of separate arguments that will be in
8195	/// the expanded form of the corresponding pack expansion. This is both an
8196	/// input and an output parameter, which can be set by the caller if the
8197	/// number of expansions is known a priori (e.g., due to a prior substitution)
8198	/// and will be set by the callee when the number of expansions is known.
8199	/// The callee must set this value when \c ShouldExpand is \c true; it may
8200	/// set this value in other cases.
8201	///
8202	/// \returns true if an error occurred (e.g., because the parameter packs
8203	/// are to be instantiated with arguments of different lengths), false
8204	/// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
8205	/// must be set.
8206	bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,
8207	SourceRange PatternRange,
8208	ArrayRef<UnexpandedParameterPack> Unexpanded,
8209	const MultiLevelTemplateArgumentList &TemplateArgs,
8210	bool &ShouldExpand,
8211	bool &RetainExpansion,
8212	Optional<unsigned> &NumExpansions);
8213
8214	/// Determine the number of arguments in the given pack expansion
8215	/// type.
8216	///
8217	/// This routine assumes that the number of arguments in the expansion is
8218	/// consistent across all of the unexpanded parameter packs in its pattern.
8219	///
8220	/// Returns an empty Optional if the type can't be expanded.
8221	Optional<unsigned> getNumArgumentsInExpansion(QualType T,
8222	const MultiLevelTemplateArgumentList &TemplateArgs);
8223
8224	/// Determine whether the given declarator contains any unexpanded
8225	/// parameter packs.
8226	///
8227	/// This routine is used by the parser to disambiguate function declarators
8228	/// with an ellipsis prior to the ')', e.g.,
8229	///
8230	/// \code
8231	/// void f(T...);
8232	/// \endcode
8233	///
8234	/// To determine whether we have an (unnamed) function parameter pack or
8235	/// a variadic function.
8236	///
8237	/// \returns true if the declarator contains any unexpanded parameter packs,
8238	/// false otherwise.
8239	bool containsUnexpandedParameterPacks(Declarator &D);
8240
8241	/// Returns the pattern of the pack expansion for a template argument.
8242	///
8243	/// \param OrigLoc The template argument to expand.
8244	///
8245	/// \param Ellipsis Will be set to the location of the ellipsis.
8246	///
8247	/// \param NumExpansions Will be set to the number of expansions that will
8248	/// be generated from this pack expansion, if known a priori.
8249	TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(
8250	TemplateArgumentLoc OrigLoc,
8251	SourceLocation &Ellipsis,
8252	Optional<unsigned> &NumExpansions) const;
8253
8254	/// Given a template argument that contains an unexpanded parameter pack, but
8255	/// which has already been substituted, attempt to determine the number of
8256	/// elements that will be produced once this argument is fully-expanded.
8257	///
8258	/// This is intended for use when transforming 'sizeof...(Arg)' in order to
8259	/// avoid actually expanding the pack where possible.
8260	Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
8261
8262	//===--------------------------------------------------------------------===//
8263	// C++ Template Argument Deduction (C++ [temp.deduct])
8264	//===--------------------------------------------------------------------===//
8265
8266	/// Adjust the type \p ArgFunctionType to match the calling convention,
8267	/// noreturn, and optionally the exception specification of \p FunctionType.
8268	/// Deduction often wants to ignore these properties when matching function
8269	/// types.
8270	QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType,
8271	bool AdjustExceptionSpec = false);
8272
8273	/// Describes the result of template argument deduction.
8274	///
8275	/// The TemplateDeductionResult enumeration describes the result of
8276	/// template argument deduction, as returned from
8277	/// DeduceTemplateArguments(). The separate TemplateDeductionInfo
8278	/// structure provides additional information about the results of
8279	/// template argument deduction, e.g., the deduced template argument
8280	/// list (if successful) or the specific template parameters or
8281	/// deduced arguments that were involved in the failure.
8282	enum TemplateDeductionResult {
8283	/// Template argument deduction was successful.
8284	TDK_Success = `0`,
8285	/// The declaration was invalid; do nothing.
8286	TDK_Invalid,
8287	/// Template argument deduction exceeded the maximum template
8288	/// instantiation depth (which has already been diagnosed).
8289	TDK_InstantiationDepth,
8290	/// Template argument deduction did not deduce a value
8291	/// for every template parameter.
8292	TDK_Incomplete,
8293	/// Template argument deduction did not deduce a value for every
8294	/// expansion of an expanded template parameter pack.
8295	TDK_IncompletePack,
8296	/// Template argument deduction produced inconsistent
8297	/// deduced values for the given template parameter.
8298	TDK_Inconsistent,
8299	/// Template argument deduction failed due to inconsistent
8300	/// cv-qualifiers on a template parameter type that would
8301	/// otherwise be deduced, e.g., we tried to deduce T in "const T"
8302	/// but were given a non-const "X".
8303	TDK_Underqualified,
8304	/// Substitution of the deduced template argument values
8305	/// resulted in an error.
8306	TDK_SubstitutionFailure,
8307	/// After substituting deduced template arguments, a dependent
8308	/// parameter type did not match the corresponding argument.
8309	TDK_DeducedMismatch,
8310	/// After substituting deduced template arguments, an element of
8311	/// a dependent parameter type did not match the corresponding element
8312	/// of the corresponding argument (when deducing from an initializer list).
8313	TDK_DeducedMismatchNested,
8314	/// A non-depnedent component of the parameter did not match the
8315	/// corresponding component of the argument.
8316	TDK_NonDeducedMismatch,
8317	/// When performing template argument deduction for a function
8318	/// template, there were too many call arguments.
8319	TDK_TooManyArguments,
8320	/// When performing template argument deduction for a function
8321	/// template, there were too few call arguments.
8322	TDK_TooFewArguments,
8323	/// The explicitly-specified template arguments were not valid
8324	/// template arguments for the given template.
8325	TDK_InvalidExplicitArguments,
8326	/// Checking non-dependent argument conversions failed.
8327	TDK_NonDependentConversionFailure,
8328	/// The deduced arguments did not satisfy the constraints associated
8329	/// with the template.
8330	TDK_ConstraintsNotSatisfied,
8331	/// Deduction failed; that's all we know.
8332	TDK_MiscellaneousDeductionFailure,
8333	/// CUDA Target attributes do not match.
8334	TDK_CUDATargetMismatch
8335	};
8336
8337	TemplateDeductionResult
8338	DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
8339	const TemplateArgumentList &TemplateArgs,
8340	sema::TemplateDeductionInfo &Info);
8341
8342	TemplateDeductionResult
8343	DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
8344	const TemplateArgumentList &TemplateArgs,
8345	sema::TemplateDeductionInfo &Info);
8346
8347	TemplateDeductionResult SubstituteExplicitTemplateArguments(
8348	FunctionTemplateDecl *FunctionTemplate,
8349	TemplateArgumentListInfo &ExplicitTemplateArgs,
8350	SmallVectorImpl<DeducedTemplateArgument> &Deduced,
8351	SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType,
8352	sema::TemplateDeductionInfo &Info);
8353
8354	/// brief A function argument from which we performed template argument
8355	// deduction for a call.
8356	struct OriginalCallArg {
8357	OriginalCallArg(QualType OriginalParamType, bool DecomposedParam,
8358	unsigned ArgIdx, QualType OriginalArgType)
8359	: OriginalParamType (OriginalParamType),
8360	DecomposedParam(DecomposedParam), ArgIdx(ArgIdx),
8361	OriginalArgType (OriginalArgType) {}
8362
8363	QualType OriginalParamType;
8364	bool DecomposedParam;
8365	unsigned ArgIdx;
8366	QualType OriginalArgType;
8367	};
8368
8369	TemplateDeductionResult FinishTemplateArgumentDeduction(
8370	FunctionTemplateDecl *FunctionTemplate,
8371	SmallVectorImpl<DeducedTemplateArgument> &Deduced,
8372	unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
8373	sema::TemplateDeductionInfo &Info,
8374	SmallVectorImpl<OriginalCallArg> const OriginalCallArgs = nullptr*,
8375	bool PartialOverloading = false,
8376	llvm::function_ref<bool()> CheckNonDependent = []{ return false; });
8377
8378	TemplateDeductionResult DeduceTemplateArguments(
8379	FunctionTemplateDecl *FunctionTemplate,
8380	TemplateArgumentListInfo ExplicitTemplateArgs, ArrayRef<Expr > Args,
8381	FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,
8382	bool PartialOverloading,
8383	llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);
8384
8385	TemplateDeductionResult
8386	DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8387	TemplateArgumentListInfo *ExplicitTemplateArgs,
8388	QualType ArgFunctionType,
8389	FunctionDecl *&Specialization,
8390	sema::TemplateDeductionInfo &Info,
8391	bool IsAddressOfFunction = false);
8392
8393	TemplateDeductionResult
8394	DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8395	QualType ToType,
8396	CXXConversionDecl *&Specialization,
8397	sema::TemplateDeductionInfo &Info);
8398
8399	TemplateDeductionResult
8400	DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8401	TemplateArgumentListInfo *ExplicitTemplateArgs,
8402	FunctionDecl *&Specialization,
8403	sema::TemplateDeductionInfo &Info,
8404	bool IsAddressOfFunction = false);
8405
8406	/// Substitute Replacement for \p auto in \p TypeWithAuto
8407	QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);
8408	/// Substitute Replacement for auto in TypeWithAuto
8409	TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
8410	QualType Replacement);
8411	/// Completely replace the \c auto in \p TypeWithAuto by
8412	/// \p Replacement. This does not retain any \c auto type sugar.
8413	QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);
8414	TypeSourceInfo ReplaceAutoTypeSourceInfo(TypeSourceInfo TypeWithAuto,
8415	QualType Replacement);
8416
8417	/// Result type of DeduceAutoType.
8418	enum DeduceAutoResult {
8419	DAR_Succeeded,
8420	DAR_Failed,
8421	DAR_FailedAlreadyDiagnosed
8422	};
8423
8424	DeduceAutoResult
8425	DeduceAutoType(TypeSourceInfo AutoType, Expr &Initializer, QualType &Result,
8426	Optional<unsigned> DependentDeductionDepth = None,
8427	bool IgnoreConstraints = false);
8428	DeduceAutoResult
8429	DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
8430	Optional<unsigned> DependentDeductionDepth = None,
8431	bool IgnoreConstraints = false);
8432	void DiagnoseAutoDeductionFailure(VarDecl VDecl, Expr Init);
8433	bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
8434	bool Diagnose = true);
8435
8436	/// Declare implicit deduction guides for a class template if we've
8437	/// not already done so.
8438	void DeclareImplicitDeductionGuides(TemplateDecl *Template,
8439	SourceLocation Loc);
8440
8441	QualType DeduceTemplateSpecializationFromInitializer(
8442	TypeSourceInfo TInfo, const* InitializedEntity &Entity,
8443	const InitializationKind &Kind, MultiExprArg Init);
8444
8445	QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,
8446	QualType Type, TypeSourceInfo *TSI,
8447	SourceRange Range, bool DirectInit,
8448	Expr *Init);
8449
8450	TypeLoc getReturnTypeLoc(FunctionDecl FD) const*;
8451
8452	bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
8453	SourceLocation ReturnLoc,
8454	Expr &RetExpr, AutoType AT);
8455
8456	FunctionTemplateDecl *getMoreSpecializedTemplate(
8457	FunctionTemplateDecl FT1, FunctionTemplateDecl FT2, SourceLocation Loc,
8458	TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1,
8459	unsigned NumCallArguments2, bool Reversed = false);
8460	UnresolvedSetIterator
8461	getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,
8462	TemplateSpecCandidateSet &FailedCandidates,
8463	SourceLocation Loc,
8464	const PartialDiagnostic &NoneDiag,
8465	const PartialDiagnostic &AmbigDiag,
8466	const PartialDiagnostic &CandidateDiag,
8467	bool Complain = true, QualType TargetType = QualType ());
8468
8469	ClassTemplatePartialSpecializationDecl *
8470	getMoreSpecializedPartialSpecialization(
8471	ClassTemplatePartialSpecializationDecl *PS1,
8472	ClassTemplatePartialSpecializationDecl *PS2,
8473	SourceLocation Loc);
8474
8475	bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T,
8476	sema::TemplateDeductionInfo &Info);
8477
8478	VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(
8479	VarTemplatePartialSpecializationDecl *PS1,
8480	VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);
8481
8482	bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,
8483	sema::TemplateDeductionInfo &Info);
8484
8485	bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
8486	TemplateParameterList PParam, TemplateDecl AArg, SourceLocation Loc);
8487
8488	void MarkUsedTemplateParameters(const Expr E, bool* OnlyDeduced,
8489	unsigned Depth, llvm::SmallBitVector &Used);
8490
8491	void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
8492	bool OnlyDeduced,
8493	unsigned Depth,
8494	llvm::SmallBitVector &Used);
8495	void MarkDeducedTemplateParameters(
8496	const FunctionTemplateDecl *FunctionTemplate,
8497	llvm::SmallBitVector &Deduced) {
8498	return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);
8499	}
8500	static void MarkDeducedTemplateParameters(ASTContext &Ctx,
8501	const FunctionTemplateDecl *FunctionTemplate,
8502	llvm::SmallBitVector &Deduced);
8503
8504	//===--------------------------------------------------------------------===//
8505	// C++ Template Instantiation
8506	//
8507
8508	MultiLevelTemplateArgumentList
8509	getTemplateInstantiationArgs(NamedDecl *D,
8510	const TemplateArgumentList Innermost = nullptr*,
8511	bool RelativeToPrimary = false,
8512	const FunctionDecl Pattern = nullptr*);
8513
8514	/// A context in which code is being synthesized (where a source location
8515	/// alone is not sufficient to identify the context). This covers template
8516	/// instantiation and various forms of implicitly-generated functions.
8517	struct CodeSynthesisContext {
8518	/// The kind of template instantiation we are performing
8519	enum SynthesisKind {
8520	/// We are instantiating a template declaration. The entity is
8521	/// the declaration we're instantiating (e.g., a CXXRecordDecl).
8522	TemplateInstantiation,
8523
8524	/// We are instantiating a default argument for a template
8525	/// parameter. The Entity is the template parameter whose argument is
8526	/// being instantiated, the Template is the template, and the
8527	/// TemplateArgs/NumTemplateArguments provide the template arguments as
8528	/// specified.
8529	DefaultTemplateArgumentInstantiation,
8530
8531	/// We are instantiating a default argument for a function.
8532	/// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs
8533	/// provides the template arguments as specified.
8534	DefaultFunctionArgumentInstantiation,
8535
8536	/// We are substituting explicit template arguments provided for
8537	/// a function template. The entity is a FunctionTemplateDecl.
8538	ExplicitTemplateArgumentSubstitution,
8539
8540	/// We are substituting template argument determined as part of
8541	/// template argument deduction for either a class template
8542	/// partial specialization or a function template. The
8543	/// Entity is either a {Class\|Var}TemplatePartialSpecializationDecl or
8544	/// a TemplateDecl.
8545	DeducedTemplateArgumentSubstitution,
8546
8547	/// We are substituting prior template arguments into a new
8548	/// template parameter. The template parameter itself is either a
8549	/// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
8550	PriorTemplateArgumentSubstitution,
8551
8552	/// We are checking the validity of a default template argument that
8553	/// has been used when naming a template-id.
8554	DefaultTemplateArgumentChecking,
8555
8556	/// We are computing the exception specification for a defaulted special
8557	/// member function.
8558	ExceptionSpecEvaluation,
8559
8560	/// We are instantiating the exception specification for a function
8561	/// template which was deferred until it was needed.
8562	ExceptionSpecInstantiation,
8563
8564	/// We are instantiating a requirement of a requires expression.
8565	RequirementInstantiation,
8566
8567	/// We are checking the satisfaction of a nested requirement of a requires
8568	/// expression.
8569	NestedRequirementConstraintsCheck,
8570
8571	/// We are declaring an implicit special member function.
8572	DeclaringSpecialMember,
8573
8574	/// We are declaring an implicit 'operator==' for a defaulted
8575	/// 'operator<=>'.
8576	DeclaringImplicitEqualityComparison,
8577
8578	/// We are defining a synthesized function (such as a defaulted special
8579	/// member).
8580	DefiningSynthesizedFunction,
8581
8582	// We are checking the constraints associated with a constrained entity or
8583	// the constraint expression of a concept. This includes the checks that
8584	// atomic constraints have the type 'bool' and that they can be constant
8585	// evaluated.
8586	ConstraintsCheck,
8587
8588	// We are substituting template arguments into a constraint expression.
8589	ConstraintSubstitution,
8590
8591	// We are normalizing a constraint expression.
8592	ConstraintNormalization,
8593
8594	// We are substituting into the parameter mapping of an atomic constraint
8595	// during normalization.
8596	ParameterMappingSubstitution,
8597
8598	/// We are rewriting a comparison operator in terms of an operator<=>.
8599	RewritingOperatorAsSpaceship,
8600
8601	/// We are initializing a structured binding.
8602	InitializingStructuredBinding,
8603
8604	/// We are marking a class as __dllexport.
8605	MarkingClassDllexported,
8606
8607	/// Added for Template instantiation observation.
8608	/// Memoization means we are _not_ instantiating a template because
8609	/// it is already instantiated (but we entered a context where we
8610	/// would have had to if it was not already instantiated).
8611	Memoization
8612	} Kind;
8613
8614	/// Was the enclosing context a non-instantiation SFINAE context?
8615	bool SavedInNonInstantiationSFINAEContext;
8616
8617	/// The point of instantiation or synthesis within the source code.
8618	SourceLocation PointOfInstantiation;
8619
8620	/// The entity that is being synthesized.
8621	Decl *Entity;
8622
8623	/// The template (or partial specialization) in which we are
8624	/// performing the instantiation, for substitutions of prior template
8625	/// arguments.
8626	NamedDecl *Template;
8627
8628	/// The list of template arguments we are substituting, if they
8629	/// are not part of the entity.
8630	const TemplateArgument *TemplateArgs;
8631
8632	// FIXME: Wrap this union around more members, or perhaps store the
8633	// kind-specific members in the RAII object owning the context.
8634	union {
8635	/// The number of template arguments in TemplateArgs.
8636	unsigned NumTemplateArgs;
8637
8638	/// The special member being declared or defined.
8639	CXXSpecialMember SpecialMember;
8640	};
8641
8642	ArrayRef<TemplateArgument> template_arguments() const {
8643	assert(Kind != DeclaringSpecialMember);
8644	return {TemplateArgs, NumTemplateArgs};
8645	}
8646
8647	/// The template deduction info object associated with the
8648	/// substitution or checking of explicit or deduced template arguments.
8649	sema::TemplateDeductionInfo *DeductionInfo;
8650
8651	/// The source range that covers the construct that cause
8652	/// the instantiation, e.g., the template-id that causes a class
8653	/// template instantiation.
8654	SourceRange InstantiationRange;
8655
8656	CodeSynthesisContext()
8657	: Kind(TemplateInstantiation),
8658	SavedInNonInstantiationSFINAEContext(false), Entity(nullptr),
8659	Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(`0`),
8660	DeductionInfo(nullptr) {}
8661
8662	/// Determines whether this template is an actual instantiation
8663	/// that should be counted toward the maximum instantiation depth.
8664	bool isInstantiationRecord() const;
8665	};
8666
8667	/// List of active code synthesis contexts.
8668	///
8669	/// This vector is treated as a stack. As synthesis of one entity requires
8670	/// synthesis of another, additional contexts are pushed onto the stack.
8671	SmallVector<CodeSynthesisContext, `16`> CodeSynthesisContexts;
8672
8673	/// Specializations whose definitions are currently being instantiated.
8674	llvm::DenseSet<std::pair<Decl , unsigned*>> InstantiatingSpecializations;
8675
8676	/// Non-dependent types used in templates that have already been instantiated
8677	/// by some template instantiation.
8678	llvm::DenseSet<QualType> InstantiatedNonDependentTypes;
8679
8680	/// Extra modules inspected when performing a lookup during a template
8681	/// instantiation. Computed lazily.
8682	SmallVector<Module*, `16`> CodeSynthesisContextLookupModules;
8683
8684	/// Cache of additional modules that should be used for name lookup
8685	/// within the current template instantiation. Computed lazily; use
8686	/// getLookupModules() to get a complete set.
8687	llvm::DenseSet<Module*> LookupModulesCache;
8688
8689	/// Get the set of additional modules that should be checked during
8690	/// name lookup. A module and its imports become visible when instanting a
8691	/// template defined within it.
8692	llvm::DenseSet<Module*> &getLookupModules();
8693
8694	/// Map from the most recent declaration of a namespace to the most
8695	/// recent visible declaration of that namespace.
8696	llvm::DenseMap<NamedDecl, NamedDecl> VisibleNamespaceCache;
8697
8698	/// Whether we are in a SFINAE context that is not associated with
8699	/// template instantiation.
8700	///
8701	/// This is used when setting up a SFINAE trap (\c see SFINAETrap) outside
8702	/// of a template instantiation or template argument deduction.
8703	bool InNonInstantiationSFINAEContext;
8704
8705	/// The number of \p CodeSynthesisContexts that are not template
8706	/// instantiations and, therefore, should not be counted as part of the
8707	/// instantiation depth.
8708	///
8709	/// When the instantiation depth reaches the user-configurable limit
8710	/// \p LangOptions::InstantiationDepth we will abort instantiation.
8711	// FIXME: Should we have a similar limit for other forms of synthesis?
8712	unsigned NonInstantiationEntries;
8713
8714	/// The depth of the context stack at the point when the most recent
8715	/// error or warning was produced.
8716	///
8717	/// This value is used to suppress printing of redundant context stacks
8718	/// when there are multiple errors or warnings in the same instantiation.
8719	// FIXME: Does this belong in Sema? It's tough to implement it anywhere else.
8720	unsigned LastEmittedCodeSynthesisContextDepth = `0`;
8721
8722	/// The template instantiation callbacks to trace or track
8723	/// instantiations (objects can be chained).
8724	///
8725	/// This callbacks is used to print, trace or track template
8726	/// instantiations as they are being constructed.
8727	std::vector<std::unique_ptr<TemplateInstantiationCallback>>
8728	TemplateInstCallbacks;
8729
8730	/// The current index into pack expansion arguments that will be
8731	/// used for substitution of parameter packs.
8732	///
8733	/// The pack expansion index will be -1 to indicate that parameter packs
8734	/// should be instantiated as themselves. Otherwise, the index specifies
8735	/// which argument within the parameter pack will be used for substitution.
8736	int ArgumentPackSubstitutionIndex;
8737
8738	/// RAII object used to change the argument pack substitution index
8739	/// within a \c Sema object.
8740	///
8741	/// See \c ArgumentPackSubstitutionIndex for more information.
8742	class ArgumentPackSubstitutionIndexRAII {
8743	Sema &Self;
8744	int OldSubstitutionIndex;
8745
8746	public:
8747	ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)
8748	: Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) {
8749	Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex;
8750	}
8751
8752	~ArgumentPackSubstitutionIndexRAII() {
8753	Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex;
8754	}
8755	};
8756
8757	friend class ArgumentPackSubstitutionRAII;
8758
8759	/// For each declaration that involved template argument deduction, the
8760	/// set of diagnostics that were suppressed during that template argument
8761	/// deduction.
8762	///
8763	/// FIXME: Serialize this structure to the AST file.
8764	typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, `1`> >
8765	SuppressedDiagnosticsMap;
8766	SuppressedDiagnosticsMap SuppressedDiagnostics;
8767
8768	/// A stack object to be created when performing template
8769	/// instantiation.
8770	///
8771	/// Construction of an object of type \c InstantiatingTemplate
8772	/// pushes the current instantiation onto the stack of active
8773	/// instantiations. If the size of this stack exceeds the maximum
8774	/// number of recursive template instantiations, construction
8775	/// produces an error and evaluates true.
8776	///
8777	/// Destruction of this object will pop the named instantiation off
8778	/// the stack.
8779	struct InstantiatingTemplate {
8780	/// Note that we are instantiating a class template,
8781	/// function template, variable template, alias template,
8782	/// or a member thereof.
8783	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8784	Decl *Entity,
8785	SourceRange InstantiationRange = SourceRange ());
8786
8787	struct ExceptionSpecification {};
8788	/// Note that we are instantiating an exception specification
8789	/// of a function template.
8790	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8791	FunctionDecl *Entity, ExceptionSpecification,
8792	SourceRange InstantiationRange = SourceRange ());
8793
8794	/// Note that we are instantiating a default argument in a
8795	/// template-id.
8796	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8797	TemplateParameter Param, TemplateDecl *Template,
8798	ArrayRef<TemplateArgument> TemplateArgs,
8799	SourceRange InstantiationRange = SourceRange ());
8800
8801	/// Note that we are substituting either explicitly-specified or
8802	/// deduced template arguments during function template argument deduction.
8803	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8804	FunctionTemplateDecl *FunctionTemplate,
8805	ArrayRef<TemplateArgument> TemplateArgs,
8806	CodeSynthesisContext::SynthesisKind Kind,
8807	sema::TemplateDeductionInfo &DeductionInfo,
8808	SourceRange InstantiationRange = SourceRange ());
8809
8810	/// Note that we are instantiating as part of template
8811	/// argument deduction for a class template declaration.
8812	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8813	TemplateDecl *Template,
8814	ArrayRef<TemplateArgument> TemplateArgs,
8815	sema::TemplateDeductionInfo &DeductionInfo,
8816	SourceRange InstantiationRange = SourceRange ());
8817
8818	/// Note that we are instantiating as part of template
8819	/// argument deduction for a class template partial
8820	/// specialization.
8821	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8822	ClassTemplatePartialSpecializationDecl *PartialSpec,
8823	ArrayRef<TemplateArgument> TemplateArgs,
8824	sema::TemplateDeductionInfo &DeductionInfo,
8825	SourceRange InstantiationRange = SourceRange ());
8826
8827	/// Note that we are instantiating as part of template
8828	/// argument deduction for a variable template partial
8829	/// specialization.
8830	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8831	VarTemplatePartialSpecializationDecl *PartialSpec,
8832	ArrayRef<TemplateArgument> TemplateArgs,
8833	sema::TemplateDeductionInfo &DeductionInfo,
8834	SourceRange InstantiationRange = SourceRange ());
8835
8836	/// Note that we are instantiating a default argument for a function
8837	/// parameter.
8838	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8839	ParmVarDecl *Param,
8840	ArrayRef<TemplateArgument> TemplateArgs,
8841	SourceRange InstantiationRange = SourceRange ());
8842
8843	/// Note that we are substituting prior template arguments into a
8844	/// non-type parameter.
8845	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8846	NamedDecl *Template,
8847	NonTypeTemplateParmDecl *Param,
8848	ArrayRef<TemplateArgument> TemplateArgs,
8849	SourceRange InstantiationRange);
8850
8851	/// Note that we are substituting prior template arguments into a
8852	/// template template parameter.
8853	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8854	NamedDecl *Template,
8855	TemplateTemplateParmDecl *Param,
8856	ArrayRef<TemplateArgument> TemplateArgs,
8857	SourceRange InstantiationRange);
8858
8859	/// Note that we are checking the default template argument
8860	/// against the template parameter for a given template-id.
8861	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8862	TemplateDecl *Template,
8863	NamedDecl *Param,
8864	ArrayRef<TemplateArgument> TemplateArgs,
8865	SourceRange InstantiationRange);
8866
8867	struct ConstraintsCheck {};
8868	/// \brief Note that we are checking the constraints associated with some
8869	/// constrained entity (a concept declaration or a template with associated
8870	/// constraints).
8871	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8872	ConstraintsCheck, NamedDecl *Template,
8873	ArrayRef<TemplateArgument> TemplateArgs,
8874	SourceRange InstantiationRange);
8875
8876	struct ConstraintSubstitution {};
8877	/// \brief Note that we are checking a constraint expression associated
8878	/// with a template declaration or as part of the satisfaction check of a
8879	/// concept.
8880	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8881	ConstraintSubstitution, NamedDecl *Template,
8882	sema::TemplateDeductionInfo &DeductionInfo,
8883	SourceRange InstantiationRange);
8884
8885	struct ConstraintNormalization {};
8886	/// \brief Note that we are normalizing a constraint expression.
8887	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8888	ConstraintNormalization, NamedDecl *Template,
8889	SourceRange InstantiationRange);
8890
8891	struct ParameterMappingSubstitution {};
8892	/// \brief Note that we are subtituting into the parameter mapping of an
8893	/// atomic constraint during constraint normalization.
8894	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8895	ParameterMappingSubstitution, NamedDecl *Template,
8896	SourceRange InstantiationRange);
8897
8898	/// \brief Note that we are substituting template arguments into a part of
8899	/// a requirement of a requires expression.
8900	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8901	concepts::Requirement *Req,
8902	sema::TemplateDeductionInfo &DeductionInfo,
8903	SourceRange InstantiationRange = SourceRange ());
8904
8905	/// \brief Note that we are checking the satisfaction of the constraint
8906	/// expression inside of a nested requirement.
8907	InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8908	concepts::NestedRequirement *Req, ConstraintsCheck,
8909	SourceRange InstantiationRange = SourceRange ());
8910
8911	/// Note that we have finished instantiating this template.
8912	void Clear();
8913
8914	~InstantiatingTemplate() { Clear(); }
8915
8916	/// Determines whether we have exceeded the maximum
8917	/// recursive template instantiations.
8918	bool isInvalid() const { return Invalid; }
8919
8920	/// Determine whether we are already instantiating this
8921	/// specialization in some surrounding active instantiation.
8922	bool isAlreadyInstantiating() const { return AlreadyInstantiating; }
8923
8924	private:
8925	Sema &SemaRef;
8926	bool Invalid;
8927	bool AlreadyInstantiating;
8928	bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
8929	SourceRange InstantiationRange);
8930
8931	InstantiatingTemplate(
8932	Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
8933	SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
8934	Decl Entity, NamedDecl Template = nullptr,
8935	ArrayRef<TemplateArgument> TemplateArgs = None,
8936	sema::TemplateDeductionInfo DeductionInfo = nullptr*);
8937
8938	InstantiatingTemplate(const InstantiatingTemplate&) = delete;
8939
8940	InstantiatingTemplate&
8941	operator=(const InstantiatingTemplate&) = delete;
8942	};
8943
8944	void pushCodeSynthesisContext(CodeSynthesisContext Ctx);
8945	void popCodeSynthesisContext();
8946
8947	/// Determine whether we are currently performing template instantiation.
8948	bool inTemplateInstantiation() const {
8949	return CodeSynthesisContexts.size() > NonInstantiationEntries;
8950	}
8951
8952	void PrintContextStack() {
8953	if (!CodeSynthesisContexts.empty() &&
8954	CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) {
8955	PrintInstantiationStack();
8956	LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size();
8957	}
8958	if (PragmaAttributeCurrentTargetDecl)
8959	PrintPragmaAttributeInstantiationPoint();
8960	}
8961	void PrintInstantiationStack();
8962
8963	void PrintPragmaAttributeInstantiationPoint();
8964
8965	/// Determines whether we are currently in a context where
8966	/// template argument substitution failures are not considered
8967	/// errors.
8968	///
8969	/// \returns An empty \c Optional if we're not in a SFINAE context.
8970	/// Otherwise, contains a pointer that, if non-NULL, contains the nearest
8971	/// template-deduction context object, which can be used to capture
8972	/// diagnostics that will be suppressed.
8973	Optional<sema::TemplateDeductionInfo > isSFINAEContext() const*;
8974
8975	/// Determines whether we are currently in a context that
8976	/// is not evaluated as per C++ [expr] p5.
8977	bool isUnevaluatedContext() const {
8978	assert(!ExprEvalContexts.empty() &&
8979	"Must be in an expression evaluation context");
8980	return ExprEvalContexts.back().isUnevaluated();
8981	}
8982
8983	/// RAII class used to determine whether SFINAE has
8984	/// trapped any errors that occur during template argument
8985	/// deduction.
8986	class SFINAETrap {
8987	Sema &SemaRef;
8988	unsigned PrevSFINAEErrors;
8989	bool PrevInNonInstantiationSFINAEContext;
8990	bool PrevAccessCheckingSFINAE;
8991	bool PrevLastDiagnosticIgnored;
8992
8993	public:
8994	explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)
8995	: SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),
8996	PrevInNonInstantiationSFINAEContext(
8997	SemaRef.InNonInstantiationSFINAEContext),
8998	PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE),
8999	PrevLastDiagnosticIgnored(
9000	SemaRef.getDiagnostics().isLastDiagnosticIgnored())
9001	{
9002	if (!SemaRef.isSFINAEContext())
9003	SemaRef.InNonInstantiationSFINAEContext = true;
9004	SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE;
9005	}
9006
9007	~SFINAETrap() {
9008	SemaRef.NumSFINAEErrors = PrevSFINAEErrors;
9009	SemaRef.InNonInstantiationSFINAEContext
9010	= PrevInNonInstantiationSFINAEContext;
9011	SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE;
9012	SemaRef.getDiagnostics().setLastDiagnosticIgnored(
9013	PrevLastDiagnosticIgnored);
9014	}
9015
9016	/// Determine whether any SFINAE errors have been trapped.
9017	bool hasErrorOccurred() const {
9018	return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
9019	}
9020	};
9021
9022	/// RAII class used to indicate that we are performing provisional
9023	/// semantic analysis to determine the validity of a construct, so
9024	/// typo-correction and diagnostics in the immediate context (not within
9025	/// implicitly-instantiated templates) should be suppressed.
9026	class TentativeAnalysisScope {
9027	Sema &SemaRef;
9028	// FIXME: Using a SFINAETrap for this is a hack.
9029	SFINAETrap Trap;
9030	bool PrevDisableTypoCorrection;
9031	public:
9032	explicit TentativeAnalysisScope(Sema &SemaRef)
9033	: SemaRef(SemaRef), Trap (SemaRef, true),
9034	PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) {
9035	SemaRef.DisableTypoCorrection = true;
9036	}
9037	~TentativeAnalysisScope() {
9038	SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection;
9039	}
9040	};
9041
9042	/// The current instantiation scope used to store local
9043	/// variables.
9044	LocalInstantiationScope *CurrentInstantiationScope;
9045
9046	/// Tracks whether we are in a context where typo correction is
9047	/// disabled.
9048	bool DisableTypoCorrection;
9049
9050	/// The number of typos corrected by CorrectTypo.
9051	unsigned TyposCorrected;
9052
9053	typedef llvm::SmallSet<SourceLocation, `2`> SrcLocSet;
9054	typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations;
9055
9056	/// A cache containing identifiers for which typo correction failed and
9057	/// their locations, so that repeated attempts to correct an identifier in a
9058	/// given location are ignored if typo correction already failed for it.
9059	IdentifierSourceLocations TypoCorrectionFailures;
9060
9061	/// Worker object for performing CFG-based warnings.
9062	sema::AnalysisBasedWarnings AnalysisWarnings;
9063	threadSafety::BeforeSet *ThreadSafetyDeclCache;
9064
9065	/// An entity for which implicit template instantiation is required.
9066	///
9067	/// The source location associated with the declaration is the first place in
9068	/// the source code where the declaration was "used". It is not necessarily
9069	/// the point of instantiation (which will be either before or after the
9070	/// namespace-scope declaration that triggered this implicit instantiation),
9071	/// However, it is the location that diagnostics should generally refer to,
9072	/// because users will need to know what code triggered the instantiation.
9073	typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
9074
9075	/// The queue of implicit template instantiations that are required
9076	/// but have not yet been performed.
9077	std::deque<PendingImplicitInstantiation> PendingInstantiations;
9078
9079	/// Queue of implicit template instantiations that cannot be performed
9080	/// eagerly.
9081	SmallVector<PendingImplicitInstantiation, `1`> LateParsedInstantiations;
9082
9083	class GlobalEagerInstantiationScope {
9084	public:
9085	GlobalEagerInstantiationScope(Sema &S, bool Enabled)
9086	: S(S), Enabled(Enabled) {
9087	if (!Enabled) return;
9088
9089	SavedPendingInstantiations.swap(S.PendingInstantiations);
9090	SavedVTableUses.swap(S.VTableUses);
9091	}
9092
9093	void perform() {
9094	if (Enabled) {
9095	S.DefineUsedVTables();
9096	S.PerformPendingInstantiations();
9097	}
9098	}
9099
9100	~GlobalEagerInstantiationScope() {
9101	if (!Enabled) return;
9102
9103	// Restore the set of pending vtables.
9104	assert(S.VTableUses.empty() &&
9105	"VTableUses should be empty before it is discarded.");
9106	S.VTableUses.swap(SavedVTableUses);
9107
9108	// Restore the set of pending implicit instantiations.
9109	if (S.TUKind != TU_Prefix \|\| !S.LangOpts.PCHInstantiateTemplates) {
9110	assert(S.PendingInstantiations.empty() &&
9111	"PendingInstantiations should be empty before it is discarded.");
9112	S.PendingInstantiations.swap(SavedPendingInstantiations);
9113	} else {
9114	// Template instantiations in the PCH may be delayed until the TU.
9115	S.PendingInstantiations.swap(SavedPendingInstantiations);
9116	S.PendingInstantiations.insert(S.PendingInstantiations.end(),
9117	SavedPendingInstantiations.begin(),
9118	SavedPendingInstantiations.end());
9119	}
9120	}
9121
9122	private:
9123	Sema &S;
9124	SmallVector<VTableUse, `16`> SavedVTableUses;
9125	std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
9126	bool Enabled;
9127	};
9128
9129	/// The queue of implicit template instantiations that are required
9130	/// and must be performed within the current local scope.
9131	///
9132	/// This queue is only used for member functions of local classes in
9133	/// templates, which must be instantiated in the same scope as their
9134	/// enclosing function, so that they can reference function-local
9135	/// types, static variables, enumerators, etc.
9136	std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations;
9137
9138	class LocalEagerInstantiationScope {
9139	public:
9140	LocalEagerInstantiationScope(Sema &S) : S(S) {
9141	SavedPendingLocalImplicitInstantiations.swap(
9142	S.PendingLocalImplicitInstantiations);
9143	}
9144
9145	void perform() { S.PerformPendingInstantiations(/LocalOnly=/true); }
9146
9147	~LocalEagerInstantiationScope() {
9148	assert(S.PendingLocalImplicitInstantiations.empty() &&
9149	"there shouldn't be any pending local implicit instantiations");
9150	SavedPendingLocalImplicitInstantiations.swap(
9151	S.PendingLocalImplicitInstantiations);
9152	}
9153
9154	private:
9155	Sema &S;
9156	std::deque<PendingImplicitInstantiation>
9157	SavedPendingLocalImplicitInstantiations;
9158	};
9159
9160	/// A helper class for building up ExtParameterInfos.
9161	class ExtParameterInfoBuilder {
9162	SmallVector<FunctionProtoType::ExtParameterInfo, `16`> Infos;
9163	bool HasInteresting = false;
9164
9165	public:
9166	/// Set the ExtParameterInfo for the parameter at the given index,
9167	///
9168	void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {
9169	assert(Infos.size() <= index);
9170	Infos.resize(index);
9171	Infos.push_back(info);
9172
9173	if (!HasInteresting)
9174	HasInteresting = (info != FunctionProtoType::ExtParameterInfo ());
9175	}
9176
9177	/// Return a pointer (suitable for setting in an ExtProtoInfo) to the
9178	/// ExtParameterInfo array we've built up.
9179	const FunctionProtoType::ExtParameterInfo *
9180	getPointerOrNull(unsigned numParams) {
9181	if (!HasInteresting) return nullptr;
9182	Infos.resize(numParams);
9183	return Infos.data();
9184	}
9185	};
9186
9187	void PerformPendingInstantiations(bool LocalOnly = false);
9188
9189	TypeSourceInfo SubstType(TypeSourceInfo T,
9190	const MultiLevelTemplateArgumentList &TemplateArgs,
9191	SourceLocation Loc, DeclarationName Entity,
9192	bool AllowDeducedTST = false);
9193
9194	QualType SubstType(QualType T,
9195	const MultiLevelTemplateArgumentList &TemplateArgs,
9196	SourceLocation Loc, DeclarationName Entity);
9197
9198	TypeSourceInfo *SubstType(TypeLoc TL,
9199	const MultiLevelTemplateArgumentList &TemplateArgs,
9200	SourceLocation Loc, DeclarationName Entity);
9201
9202	TypeSourceInfo SubstFunctionDeclType(TypeSourceInfo T,
9203	const MultiLevelTemplateArgumentList &TemplateArgs,
9204	SourceLocation Loc,
9205	DeclarationName Entity,
9206	CXXRecordDecl *ThisContext,
9207	Qualifiers ThisTypeQuals);
9208	void SubstExceptionSpec(FunctionDecl New, const* FunctionProtoType *Proto,
9209	const MultiLevelTemplateArgumentList &Args);
9210	bool SubstExceptionSpec(SourceLocation Loc,
9211	FunctionProtoType::ExceptionSpecInfo &ESI,
9212	SmallVectorImpl<QualType> &ExceptionStorage,
9213	const MultiLevelTemplateArgumentList &Args);
9214	ParmVarDecl SubstParmVarDecl(ParmVarDecl D,
9215	const MultiLevelTemplateArgumentList &TemplateArgs,
9216	int indexAdjustment,
9217	Optional<unsigned> NumExpansions,
9218	bool ExpectParameterPack);
9219	bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
9220	const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
9221	const MultiLevelTemplateArgumentList &TemplateArgs,
9222	SmallVectorImpl<QualType> &ParamTypes,
9223	SmallVectorImpl<ParmVarDecl > OutParams,
9224	ExtParameterInfoBuilder &ParamInfos);
9225	ExprResult SubstExpr(Expr *E,
9226	const MultiLevelTemplateArgumentList &TemplateArgs);
9227
9228	/// Substitute the given template arguments into a list of
9229	/// expressions, expanding pack expansions if required.
9230	///
9231	/// \param Exprs The list of expressions to substitute into.
9232	///
9233	/// \param IsCall Whether this is some form of call, in which case
9234	/// default arguments will be dropped.
9235	///
9236	/// \param TemplateArgs The set of template arguments to substitute.
9237	///
9238	/// \param Outputs Will receive all of the substituted arguments.
9239	///
9240	/// \returns true if an error occurred, false otherwise.
9241	bool SubstExprs(ArrayRef<Expr > Exprs, bool* IsCall,
9242	const MultiLevelTemplateArgumentList &TemplateArgs,
9243	SmallVectorImpl<Expr *> &Outputs);
9244
9245	StmtResult SubstStmt(Stmt *S,
9246	const MultiLevelTemplateArgumentList &TemplateArgs);
9247
9248	TemplateParameterList *
9249	SubstTemplateParams(TemplateParameterList Params, DeclContext Owner,
9250	const MultiLevelTemplateArgumentList &TemplateArgs);
9251
9252	bool
9253	SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
9254	const MultiLevelTemplateArgumentList &TemplateArgs,
9255	TemplateArgumentListInfo &Outputs);
9256
9257
9258	Decl SubstDecl(Decl D, DeclContext *Owner,
9259	const MultiLevelTemplateArgumentList &TemplateArgs);
9260
9261	/// Substitute the name and return type of a defaulted 'operator<=>' to form
9262	/// an implicit 'operator=='.
9263	FunctionDecl SubstSpaceshipAsEqualEqual(CXXRecordDecl RD,
9264	FunctionDecl *Spaceship);
9265
9266	ExprResult SubstInitializer(Expr *E,
9267	const MultiLevelTemplateArgumentList &TemplateArgs,
9268	bool CXXDirectInit);
9269
9270	bool
9271	SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
9272	CXXRecordDecl *Pattern,
9273	const MultiLevelTemplateArgumentList &TemplateArgs);
9274
9275	bool
9276	InstantiateClass(SourceLocation PointOfInstantiation,
9277	CXXRecordDecl Instantiation, CXXRecordDecl Pattern,
9278	const MultiLevelTemplateArgumentList &TemplateArgs,
9279	TemplateSpecializationKind TSK,
9280	bool Complain = true);
9281
9282	bool InstantiateEnum(SourceLocation PointOfInstantiation,
9283	EnumDecl Instantiation, EnumDecl Pattern,
9284	const MultiLevelTemplateArgumentList &TemplateArgs,
9285	TemplateSpecializationKind TSK);
9286
9287	bool InstantiateInClassInitializer(
9288	SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
9289	FieldDecl Pattern, const* MultiLevelTemplateArgumentList &TemplateArgs);
9290
9291	struct LateInstantiatedAttribute {
9292	const Attr *TmplAttr;
9293	LocalInstantiationScope *Scope;
9294	Decl *NewDecl;
9295
9296	LateInstantiatedAttribute(const Attr A, LocalInstantiationScope S,
9297	Decl *D)
9298	: TmplAttr(A), Scope(S), NewDecl(D)
9299	{ }
9300	};
9301	typedef SmallVector<LateInstantiatedAttribute, `16`> LateInstantiatedAttrVec;
9302
9303	void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
9304	const Decl Pattern, Decl Inst,
9305	LateInstantiatedAttrVec LateAttrs = nullptr*,
9306	LocalInstantiationScope OuterMostScope = nullptr*);
9307
9308	void
9309	InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,
9310	const Decl Pattern, Decl Inst,
9311	LateInstantiatedAttrVec LateAttrs = nullptr*,
9312	LocalInstantiationScope OuterMostScope = nullptr*);
9313
9314	void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor);
9315
9316	bool usesPartialOrExplicitSpecialization(
9317	SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);
9318
9319	bool
9320	InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
9321	ClassTemplateSpecializationDecl *ClassTemplateSpec,
9322	TemplateSpecializationKind TSK,
9323	bool Complain = true);
9324
9325	void InstantiateClassMembers(SourceLocation PointOfInstantiation,
9326	CXXRecordDecl *Instantiation,
9327	const MultiLevelTemplateArgumentList &TemplateArgs,
9328	TemplateSpecializationKind TSK);
9329
9330	void InstantiateClassTemplateSpecializationMembers(
9331	SourceLocation PointOfInstantiation,
9332	ClassTemplateSpecializationDecl *ClassTemplateSpec,
9333	TemplateSpecializationKind TSK);
9334
9335	NestedNameSpecifierLoc
9336	SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
9337	const MultiLevelTemplateArgumentList &TemplateArgs);
9338
9339	DeclarationNameInfo
9340	SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
9341	const MultiLevelTemplateArgumentList &TemplateArgs);
9342	TemplateName
9343	SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
9344	SourceLocation Loc,
9345	const MultiLevelTemplateArgumentList &TemplateArgs);
9346	bool Subst(const TemplateArgumentLoc Args, unsigned* NumArgs,
9347	TemplateArgumentListInfo &Result,
9348	const MultiLevelTemplateArgumentList &TemplateArgs);
9349
9350	bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
9351	ParmVarDecl *Param);
9352	void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
9353	FunctionDecl *Function);
9354	bool CheckInstantiatedFunctionTemplateConstraints(
9355	SourceLocation PointOfInstantiation, FunctionDecl *Decl,
9356	ArrayRef<TemplateArgument> TemplateArgs,
9357	ConstraintSatisfaction &Satisfaction);
9358	FunctionDecl InstantiateFunctionDeclaration(FunctionTemplateDecl FTD,
9359	const TemplateArgumentList *Args,
9360	SourceLocation Loc);
9361	void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
9362	FunctionDecl *Function,
9363	bool Recursive = false,
9364	bool DefinitionRequired = false,
9365	bool AtEndOfTU = false);
9366	VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
9367	VarTemplateDecl VarTemplate, VarDecl FromVar,
9368	const TemplateArgumentList &TemplateArgList,
9369	const TemplateArgumentListInfo &TemplateArgsInfo,
9370	SmallVectorImpl<TemplateArgument> &Converted,
9371	SourceLocation PointOfInstantiation,
9372	LateInstantiatedAttrVec LateAttrs = nullptr*,
9373	LocalInstantiationScope StartingScope = nullptr*);
9374	VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(
9375	VarTemplateSpecializationDecl VarSpec, VarDecl PatternDecl,
9376	const MultiLevelTemplateArgumentList &TemplateArgs);
9377	void
9378	BuildVariableInstantiation(VarDecl NewVar, VarDecl OldVar,
9379	const MultiLevelTemplateArgumentList &TemplateArgs,
9380	LateInstantiatedAttrVec *LateAttrs,
9381	DeclContext *Owner,
9382	LocalInstantiationScope *StartingScope,
9383	bool InstantiatingVarTemplate = false,
9384	VarTemplateSpecializationDecl PrevVTSD = nullptr*);
9385
9386	void InstantiateVariableInitializer(
9387	VarDecl Var, VarDecl OldVar,
9388	const MultiLevelTemplateArgumentList &TemplateArgs);
9389	void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
9390	VarDecl Var, bool* Recursive = false,
9391	bool DefinitionRequired = false,
9392	bool AtEndOfTU = false);
9393
9394	void InstantiateMemInitializers(CXXConstructorDecl *New,
9395	const CXXConstructorDecl *Tmpl,
9396	const MultiLevelTemplateArgumentList &TemplateArgs);
9397
9398	NamedDecl FindInstantiatedDecl(SourceLocation Loc, NamedDecl D,
9399	const MultiLevelTemplateArgumentList &TemplateArgs,
9400	bool FindingInstantiatedContext = false);
9401	DeclContext FindInstantiatedContext(SourceLocation Loc, DeclContext DC,
9402	const MultiLevelTemplateArgumentList &TemplateArgs);
9403
9404	// Objective-C declarations.
9405	enum ObjCContainerKind {
9406	OCK_None = -`1`,
9407	OCK_Interface = `0`,
9408	OCK_Protocol,
9409	OCK_Category,
9410	OCK_ClassExtension,
9411	OCK_Implementation,
9412	OCK_CategoryImplementation
9413	};
9414	ObjCContainerKind getObjCContainerKind() const;
9415
9416	DeclResult actOnObjCTypeParam(Scope *S,
9417	ObjCTypeParamVariance variance,
9418	SourceLocation varianceLoc,
9419	unsigned index,
9420	IdentifierInfo *paramName,
9421	SourceLocation paramLoc,
9422	SourceLocation colonLoc,
9423	ParsedType typeBound);
9424
9425	ObjCTypeParamList actOnObjCTypeParamList(Scope S, SourceLocation lAngleLoc,
9426	ArrayRef<Decl *> typeParams,
9427	SourceLocation rAngleLoc);
9428	void popObjCTypeParamList(Scope S, ObjCTypeParamList typeParamList);
9429
9430	Decl *ActOnStartClassInterface(
9431	Scope S, SourceLocation AtInterfaceLoc, IdentifierInfo ClassName,
9432	SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
9433	IdentifierInfo *SuperName, SourceLocation SuperLoc,
9434	ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange,
9435	Decl *const ProtoRefs, unsigned* NumProtoRefs,
9436	const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
9437	const ParsedAttributesView &AttrList);
9438
9439	void ActOnSuperClassOfClassInterface(Scope *S,
9440	SourceLocation AtInterfaceLoc,
9441	ObjCInterfaceDecl *IDecl,
9442	IdentifierInfo *ClassName,
9443	SourceLocation ClassLoc,
9444	IdentifierInfo *SuperName,
9445	SourceLocation SuperLoc,
9446	ArrayRef<ParsedType> SuperTypeArgs,
9447	SourceRange SuperTypeArgsRange);
9448
9449	void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs,
9450	SmallVectorImpl<SourceLocation> &ProtocolLocs,
9451	IdentifierInfo *SuperName,
9452	SourceLocation SuperLoc);
9453
9454	Decl *ActOnCompatibilityAlias(
9455	SourceLocation AtCompatibilityAliasLoc,
9456	IdentifierInfo *AliasName, SourceLocation AliasLocation,
9457	IdentifierInfo *ClassName, SourceLocation ClassLocation);
9458
9459	bool CheckForwardProtocolDeclarationForCircularDependency(
9460	IdentifierInfo *PName,
9461	SourceLocation &PLoc, SourceLocation PrevLoc,
9462	const ObjCList<ObjCProtocolDecl> &PList);
9463
9464	Decl *ActOnStartProtocolInterface(
9465	SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName,
9466	SourceLocation ProtocolLoc, Decl *const *ProtoRefNames,
9467	unsigned NumProtoRefs, const SourceLocation *ProtoLocs,
9468	SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList);
9469
9470	Decl *ActOnStartCategoryInterface(
9471	SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
9472	SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
9473	IdentifierInfo *CategoryName, SourceLocation CategoryLoc,
9474	Decl *const ProtoRefs, unsigned* NumProtoRefs,
9475	const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
9476	const ParsedAttributesView &AttrList);
9477
9478	Decl *ActOnStartClassImplementation(SourceLocation AtClassImplLoc,
9479	IdentifierInfo *ClassName,
9480	SourceLocation ClassLoc,
9481	IdentifierInfo *SuperClassname,
9482	SourceLocation SuperClassLoc,
9483	const ParsedAttributesView &AttrList);
9484
9485	Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc,
9486	IdentifierInfo *ClassName,
9487	SourceLocation ClassLoc,
9488	IdentifierInfo *CatName,
9489	SourceLocation CatLoc,
9490	const ParsedAttributesView &AttrList);
9491
9492	DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,
9493	ArrayRef<Decl *> Decls);
9494
9495	DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
9496	IdentifierInfo **IdentList,
9497	SourceLocation *IdentLocs,
9498	ArrayRef<ObjCTypeParamList *> TypeParamLists,
9499	unsigned NumElts);
9500
9501	DeclGroupPtrTy
9502	ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,
9503	ArrayRef<IdentifierLocPair> IdentList,
9504	const ParsedAttributesView &attrList);
9505
9506	void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
9507	ArrayRef<IdentifierLocPair> ProtocolId,
9508	SmallVectorImpl<Decl *> &Protocols);
9509
9510	void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,
9511	SourceLocation ProtocolLoc,
9512	IdentifierInfo *TypeArgId,
9513	SourceLocation TypeArgLoc,
9514	bool SelectProtocolFirst = false);
9515
9516	/// Given a list of identifiers (and their locations), resolve the
9517	/// names to either Objective-C protocol qualifiers or type
9518	/// arguments, as appropriate.
9519	void actOnObjCTypeArgsOrProtocolQualifiers(
9520	Scope *S,
9521	ParsedType baseType,
9522	SourceLocation lAngleLoc,
9523	ArrayRef<IdentifierInfo *> identifiers,
9524	ArrayRef<SourceLocation> identifierLocs,
9525	SourceLocation rAngleLoc,
9526	SourceLocation &typeArgsLAngleLoc,
9527	SmallVectorImpl<ParsedType> &typeArgs,
9528	SourceLocation &typeArgsRAngleLoc,
9529	SourceLocation &protocolLAngleLoc,
9530	SmallVectorImpl<Decl *> &protocols,
9531	SourceLocation &protocolRAngleLoc,
9532	bool warnOnIncompleteProtocols);
9533
9534	/// Build a an Objective-C protocol-qualified 'id' type where no
9535	/// base type was specified.
9536	TypeResult actOnObjCProtocolQualifierType(
9537	SourceLocation lAngleLoc,
9538	ArrayRef<Decl *> protocols,
9539	ArrayRef<SourceLocation> protocolLocs,
9540	SourceLocation rAngleLoc);
9541
9542	/// Build a specialized and/or protocol-qualified Objective-C type.
9543	TypeResult actOnObjCTypeArgsAndProtocolQualifiers(
9544	Scope *S,
9545	SourceLocation Loc,
9546	ParsedType BaseType,
9547	SourceLocation TypeArgsLAngleLoc,
9548	ArrayRef<ParsedType> TypeArgs,
9549	SourceLocation TypeArgsRAngleLoc,
9550	SourceLocation ProtocolLAngleLoc,
9551	ArrayRef<Decl *> Protocols,
9552	ArrayRef<SourceLocation> ProtocolLocs,
9553	SourceLocation ProtocolRAngleLoc);
9554
9555	/// Build an Objective-C type parameter type.
9556	QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
9557	SourceLocation ProtocolLAngleLoc,
9558	ArrayRef<ObjCProtocolDecl *> Protocols,
9559	ArrayRef<SourceLocation> ProtocolLocs,
9560	SourceLocation ProtocolRAngleLoc,
9561	bool FailOnError = false);
9562
9563	/// Build an Objective-C object pointer type.
9564	QualType BuildObjCObjectType(QualType BaseType,
9565	SourceLocation Loc,
9566	SourceLocation TypeArgsLAngleLoc,
9567	ArrayRef<TypeSourceInfo *> TypeArgs,
9568	SourceLocation TypeArgsRAngleLoc,
9569	SourceLocation ProtocolLAngleLoc,
9570	ArrayRef<ObjCProtocolDecl *> Protocols,
9571	ArrayRef<SourceLocation> ProtocolLocs,
9572	SourceLocation ProtocolRAngleLoc,
9573	bool FailOnError = false);
9574
9575	/// Ensure attributes are consistent with type.
9576	/// \param [in, out] Attributes The attributes to check; they will
9577	/// be modified to be consistent with \p PropertyTy.
9578	void CheckObjCPropertyAttributes(Decl *PropertyPtrTy,
9579	SourceLocation Loc,
9580	unsigned &Attributes,
9581	bool propertyInPrimaryClass);
9582
9583	/// Process the specified property declaration and create decls for the
9584	/// setters and getters as needed.
9585	/// \param property The property declaration being processed
9586	void ProcessPropertyDecl(ObjCPropertyDecl *property);
9587
9588
9589	void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
9590	ObjCPropertyDecl *SuperProperty,
9591	const IdentifierInfo *Name,
9592	bool OverridingProtocolProperty);
9593
9594	void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
9595	ObjCInterfaceDecl *ID);
9596
9597	Decl ActOnAtEnd(Scope S, SourceRange AtEnd,
9598	ArrayRef<Decl *> allMethods = None,
9599	ArrayRef<DeclGroupPtrTy> allTUVars = None);
9600
9601	Decl ActOnProperty(Scope S, SourceLocation AtLoc,
9602	SourceLocation LParenLoc,
9603	FieldDeclarator &FD, ObjCDeclSpec &ODS,
9604	Selector GetterSel, Selector SetterSel,
9605	tok::ObjCKeywordKind MethodImplKind,
9606	DeclContext lexicalDC = nullptr*);
9607
9608	Decl ActOnPropertyImplDecl(Scope S,
9609	SourceLocation AtLoc,
9610	SourceLocation PropertyLoc,
9611	bool ImplKind,
9612	IdentifierInfo *PropertyId,
9613	IdentifierInfo *PropertyIvar,
9614	SourceLocation PropertyIvarLoc,
9615	ObjCPropertyQueryKind QueryKind);
9616
9617	enum ObjCSpecialMethodKind {
9618	OSMK_None,
9619	OSMK_Alloc,
9620	OSMK_New,
9621	OSMK_Copy,
9622	OSMK_RetainingInit,
9623	OSMK_NonRetainingInit
9624	};
9625
9626	struct ObjCArgInfo {
9627	IdentifierInfo *Name;
9628	SourceLocation NameLoc;
9629	// The Type is null if no type was specified, and the DeclSpec is invalid
9630	// in this case.
9631	ParsedType Type;
9632	ObjCDeclSpec DeclSpec;
9633
9634	/// ArgAttrs - Attribute list for this argument.
9635	ParsedAttributesView ArgAttrs;
9636	};
9637
9638	Decl *ActOnMethodDeclaration(
9639	Scope *S,
9640	SourceLocation BeginLoc, // location of the + or -.
9641	SourceLocation EndLoc, // location of the ; or {.
9642	tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
9643	ArrayRef<SourceLocation> SelectorLocs, Selector Sel,
9644	// optional arguments. The number of types/arguments is obtained
9645	// from the Sel.getNumArgs().
9646	ObjCArgInfo ArgInfo, DeclaratorChunk::ParamInfo CParamInfo,
9647	unsigned CNumArgs, // c-style args
9648	const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind,
9649	bool isVariadic, bool MethodDefinition);
9650
9651	ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel,
9652	const ObjCObjectPointerType *OPT,
9653	bool IsInstance);
9654	ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty,
9655	bool IsInstance);
9656
9657	bool CheckARCMethodDecl(ObjCMethodDecl *method);
9658	bool inferObjCARCLifetime(ValueDecl *decl);
9659
9660	void deduceOpenCLAddressSpace(ValueDecl *decl);
9661
9662	ExprResult
9663	HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
9664	Expr *BaseExpr,
9665	SourceLocation OpLoc,
9666	DeclarationName MemberName,
9667	SourceLocation MemberLoc,
9668	SourceLocation SuperLoc, QualType SuperType,
9669	bool Super);
9670
9671	ExprResult
9672	ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
9673	IdentifierInfo &propertyName,
9674	SourceLocation receiverNameLoc,
9675	SourceLocation propertyNameLoc);
9676
9677	ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc);
9678
9679	/// Describes the kind of message expression indicated by a message
9680	/// send that starts with an identifier.
9681	enum ObjCMessageKind {
9682	/// The message is sent to 'super'.
9683	ObjCSuperMessage,
9684	/// The message is an instance message.
9685	ObjCInstanceMessage,
9686	/// The message is a class message, and the identifier is a type
9687	/// name.
9688	ObjCClassMessage
9689	};
9690
9691	ObjCMessageKind getObjCMessageKind(Scope *S,
9692	IdentifierInfo *Name,
9693	SourceLocation NameLoc,
9694	bool IsSuper,
9695	bool HasTrailingDot,
9696	ParsedType &ReceiverType);
9697
9698	ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,
9699	Selector Sel,
9700	SourceLocation LBracLoc,
9701	ArrayRef<SourceLocation> SelectorLocs,
9702	SourceLocation RBracLoc,
9703	MultiExprArg Args);
9704
9705	ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
9706	QualType ReceiverType,
9707	SourceLocation SuperLoc,
9708	Selector Sel,
9709	ObjCMethodDecl *Method,
9710	SourceLocation LBracLoc,
9711	ArrayRef<SourceLocation> SelectorLocs,
9712	SourceLocation RBracLoc,
9713	MultiExprArg Args,
9714	bool isImplicit = false);
9715
9716	ExprResult BuildClassMessageImplicit(QualType ReceiverType,
9717	bool isSuperReceiver,
9718	SourceLocation Loc,
9719	Selector Sel,
9720	ObjCMethodDecl *Method,
9721	MultiExprArg Args);
9722
9723	ExprResult ActOnClassMessage(Scope *S,
9724	ParsedType Receiver,
9725	Selector Sel,
9726	SourceLocation LBracLoc,
9727	ArrayRef<SourceLocation> SelectorLocs,
9728	SourceLocation RBracLoc,
9729	MultiExprArg Args);
9730
9731	ExprResult BuildInstanceMessage(Expr *Receiver,
9732	QualType ReceiverType,
9733	SourceLocation SuperLoc,
9734	Selector Sel,
9735	ObjCMethodDecl *Method,
9736	SourceLocation LBracLoc,
9737	ArrayRef<SourceLocation> SelectorLocs,
9738	SourceLocation RBracLoc,
9739	MultiExprArg Args,
9740	bool isImplicit = false);
9741
9742	ExprResult BuildInstanceMessageImplicit(Expr *Receiver,
9743	QualType ReceiverType,
9744	SourceLocation Loc,
9745	Selector Sel,
9746	ObjCMethodDecl *Method,
9747	MultiExprArg Args);
9748
9749	ExprResult ActOnInstanceMessage(Scope *S,
9750	Expr *Receiver,
9751	Selector Sel,
9752	SourceLocation LBracLoc,
9753	ArrayRef<SourceLocation> SelectorLocs,
9754	SourceLocation RBracLoc,
9755	MultiExprArg Args);
9756
9757	ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc,
9758	ObjCBridgeCastKind Kind,
9759	SourceLocation BridgeKeywordLoc,
9760	TypeSourceInfo *TSInfo,
9761	Expr *SubExpr);
9762
9763	ExprResult ActOnObjCBridgedCast(Scope *S,
9764	SourceLocation LParenLoc,
9765	ObjCBridgeCastKind Kind,
9766	SourceLocation BridgeKeywordLoc,
9767	ParsedType Type,
9768	SourceLocation RParenLoc,
9769	Expr *SubExpr);
9770
9771	void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);
9772
9773	void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);
9774
9775	bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
9776	CastKind &Kind);
9777
9778	bool checkObjCBridgeRelatedComponents(SourceLocation Loc,
9779	QualType DestType, QualType SrcType,
9780	ObjCInterfaceDecl *&RelatedClass,
9781	ObjCMethodDecl *&ClassMethod,
9782	ObjCMethodDecl *&InstanceMethod,
9783	TypedefNameDecl *&TDNDecl,
9784	bool CfToNs, bool Diagnose = true);
9785
9786	bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,
9787	QualType DestType, QualType SrcType,
9788	Expr &SrcExpr, bool* Diagnose = true);
9789
9790	bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr,
9791	bool Diagnose = true);
9792
9793	bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);
9794
9795	/// Check whether the given new method is a valid override of the
9796	/// given overridden method, and set any properties that should be inherited.
9797	void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
9798	const ObjCMethodDecl *Overridden);
9799
9800	/// Describes the compatibility of a result type with its method.
9801	enum ResultTypeCompatibilityKind {
9802	RTC_Compatible,
9803	RTC_Incompatible,
9804	RTC_Unknown
9805	};
9806
9807	void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method,
9808	ObjCMethodDecl *overridden);
9809
9810	void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
9811	ObjCInterfaceDecl *CurrentClass,
9812	ResultTypeCompatibilityKind RTC);
9813
9814	enum PragmaOptionsAlignKind {
9815	POAK_Native, // #pragma options align=native
9816	POAK_Natural, // #pragma options align=natural
9817	POAK_Packed, // #pragma options align=packed
9818	POAK_Power, // #pragma options align=power
9819	POAK_Mac68k, // #pragma options align=mac68k
9820	POAK_Reset // #pragma options align=reset
9821	};
9822
9823	/// ActOnPragmaClangSection - Called on well formed \#pragma clang section
9824	void ActOnPragmaClangSection(SourceLocation PragmaLoc,
9825	PragmaClangSectionAction Action,
9826	PragmaClangSectionKind SecKind, StringRef SecName);
9827
9828	/// ActOnPragmaOptionsAlign - Called on well formed \#pragma options align.
9829	void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
9830	SourceLocation PragmaLoc);
9831
9832	/// ActOnPragmaPack - Called on well formed \#pragma pack(...).
9833	void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
9834	StringRef SlotLabel, Expr *Alignment);
9835
9836	enum class PragmaAlignPackDiagnoseKind {
9837	NonDefaultStateAtInclude,
9838	ChangedStateAtExit
9839	};
9840
9841	void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind,
9842	SourceLocation IncludeLoc);
9843	void DiagnoseUnterminatedPragmaAlignPack();
9844
9845	/// ActOnPragmaMSStruct - Called on well formed \#pragma ms_struct [on\|off].
9846	void ActOnPragmaMSStruct(PragmaMSStructKind Kind);
9847
9848	/// ActOnPragmaMSComment - Called on well formed
9849	/// \#pragma comment(kind, "arg").
9850	void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind,
9851	StringRef Arg);
9852
9853	/// ActOnPragmaMSPointersToMembers - called on well formed \#pragma
9854	/// pointers_to_members(representation method[, general purpose
9855	/// representation]).
9856	void ActOnPragmaMSPointersToMembers(
9857	LangOptions::PragmaMSPointersToMembersKind Kind,
9858	SourceLocation PragmaLoc);
9859
9860	/// Called on well formed \#pragma vtordisp().
9861	void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
9862	SourceLocation PragmaLoc,
9863	MSVtorDispMode Value);
9864
9865	enum PragmaSectionKind {
9866	PSK_DataSeg,
9867	PSK_BSSSeg,
9868	PSK_ConstSeg,
9869	PSK_CodeSeg,
9870	};
9871
9872	bool UnifySection(StringRef SectionName, int SectionFlags,
9873	NamedDecl *TheDecl);
9874	bool UnifySection(StringRef SectionName,
9875	int SectionFlags,
9876	SourceLocation PragmaSectionLocation);
9877
9878	/// Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg.
9879	void ActOnPragmaMSSeg(SourceLocation PragmaLocation,
9880	PragmaMsStackAction Action,
9881	llvm::StringRef StackSlotLabel,
9882	StringLiteral *SegmentName,
9883	llvm::StringRef PragmaName);
9884
9885	/// Called on well formed \#pragma section().
9886	void ActOnPragmaMSSection(SourceLocation PragmaLocation,
9887	int SectionFlags, StringLiteral *SegmentName);
9888
9889	/// Called on well-formed \#pragma init_seg().
9890	void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
9891	StringLiteral *SegmentName);
9892
9893	/// Called on #pragma clang __debug dump II
9894	void ActOnPragmaDump(Scope S, SourceLocation Loc, IdentifierInfo II);
9895
9896	/// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
9897	void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
9898	StringRef Value);
9899
9900	/// Are precise floating point semantics currently enabled?
9901	bool isPreciseFPEnabled() {
9902	return !CurFPFeatures.getAllowFPReassociate() &&
9903	!CurFPFeatures.getNoSignedZero() &&
9904	!CurFPFeatures.getAllowReciprocal() &&
9905	!CurFPFeatures.getAllowApproxFunc();
9906	}
9907
9908	/// ActOnPragmaFloatControl - Call on well-formed \#pragma float_control
9909	void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action,
9910	PragmaFloatControlKind Value);
9911
9912	/// ActOnPragmaUnused - Called on well-formed '\#pragma unused'.
9913	void ActOnPragmaUnused(const Token &Identifier,
9914	Scope *curScope,
9915	SourceLocation PragmaLoc);
9916
9917	/// ActOnPragmaVisibility - Called on well formed \#pragma GCC visibility... .
9918	void ActOnPragmaVisibility(const IdentifierInfo* VisType,
9919	SourceLocation PragmaLoc);
9920
9921	NamedDecl DeclClonePragmaWeak(NamedDecl ND, IdentifierInfo *II,
9922	SourceLocation Loc);
9923	void DeclApplyPragmaWeak(Scope S, NamedDecl ND, WeakInfo &W);
9924
9925	/// ActOnPragmaWeakID - Called on well formed \#pragma weak ident.
9926	void ActOnPragmaWeakID(IdentifierInfo* WeakName,
9927	SourceLocation PragmaLoc,
9928	SourceLocation WeakNameLoc);
9929
9930	/// ActOnPragmaRedefineExtname - Called on well formed
9931	/// \#pragma redefine_extname oldname newname.
9932	void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName,
9933	IdentifierInfo* AliasName,
9934	SourceLocation PragmaLoc,
9935	SourceLocation WeakNameLoc,
9936	SourceLocation AliasNameLoc);
9937
9938	/// ActOnPragmaWeakAlias - Called on well formed \#pragma weak ident = ident.
9939	void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
9940	IdentifierInfo* AliasName,
9941	SourceLocation PragmaLoc,
9942	SourceLocation WeakNameLoc,
9943	SourceLocation AliasNameLoc);
9944
9945	/// ActOnPragmaFPContract - Called on well formed
9946	/// \#pragma {STDC,OPENCL} FP_CONTRACT and
9947	/// \#pragma clang fp contract
9948	void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC);
9949
9950	/// Called on well formed
9951	/// \#pragma clang fp reassociate
9952	void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled);
9953
9954	/// ActOnPragmaFenvAccess - Called on well formed
9955	/// \#pragma STDC FENV_ACCESS
9956	void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled);
9957
9958	/// Called on well formed '\#pragma clang fp' that has option 'exceptions'.
9959	void ActOnPragmaFPExceptions(SourceLocation Loc,
9960	LangOptions::FPExceptionModeKind);
9961
9962	/// Called to set constant rounding mode for floating point operations.
9963	void setRoundingMode(SourceLocation Loc, llvm::RoundingMode);
9964
9965	/// Called to set exception behavior for floating point operations.
9966	void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind);
9967
9968	/// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to
9969	/// a the record decl, to handle '\#pragma pack' and '\#pragma options align'.
9970	void AddAlignmentAttributesForRecord(RecordDecl *RD);
9971
9972	/// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
9973	void AddMsStructLayoutForRecord(RecordDecl *RD);
9974
9975	/// PushNamespaceVisibilityAttr - Note that we've entered a
9976	/// namespace with a visibility attribute.
9977	void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
9978	SourceLocation Loc);
9979
9980	/// AddPushedVisibilityAttribute - If '\#pragma GCC visibility' was used,
9981	/// add an appropriate visibility attribute.
9982	void AddPushedVisibilityAttribute(Decl *RD);
9983
9984	/// PopPragmaVisibility - Pop the top element of the visibility stack; used
9985	/// for '\#pragma GCC visibility' and visibility attributes on namespaces.
9986	void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc);
9987
9988	/// FreeVisContext - Deallocate and null out VisContext.
9989	void FreeVisContext();
9990
9991	/// AddCFAuditedAttribute - Check whether we're currently within
9992	/// '\#pragma clang arc_cf_code_audited' and, if so, consider adding
9993	/// the appropriate attribute.
9994	void AddCFAuditedAttribute(Decl *D);
9995
9996	void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute,
9997	SourceLocation PragmaLoc,
9998	attr::ParsedSubjectMatchRuleSet Rules);
9999	void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
10000	const IdentifierInfo *Namespace);
10001
10002	/// Called on well-formed '\#pragma clang attribute pop'.
10003	void ActOnPragmaAttributePop(SourceLocation PragmaLoc,
10004	const IdentifierInfo *Namespace);
10005
10006	/// Adds the attributes that have been specified using the
10007	/// '\#pragma clang attribute push' directives to the given declaration.
10008	void AddPragmaAttributes(Scope S, Decl D);
10009
10010	void DiagnoseUnterminatedPragmaAttribute();
10011
10012	/// Called on well formed \#pragma clang optimize.
10013	void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
10014
10015	/// Get the location for the currently active "\#pragma clang optimize
10016	/// off". If this location is invalid, then the state of the pragma is "on".
10017	SourceLocation getOptimizeOffPragmaLocation() const {
10018	return OptimizeOffPragmaLocation;
10019	}
10020
10021	/// Only called on function definitions; if there is a pragma in scope
10022	/// with the effect of a range-based optnone, consider marking the function
10023	/// with attribute optnone.
10024	void AddRangeBasedOptnone(FunctionDecl *FD);
10025
10026	/// Adds the 'optnone' attribute to the function declaration if there
10027	/// are no conflicts; Loc represents the location causing the 'optnone'
10028	/// attribute to be added (usually because of a pragma).
10029	void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);
10030
10031	/// AddAlignedAttr - Adds an aligned attribute to a particular declaration.
10032	void AddAlignedAttr(Decl D, const* AttributeCommonInfo &CI, Expr *E,
10033	bool IsPackExpansion);
10034	void AddAlignedAttr(Decl D, const* AttributeCommonInfo &CI, TypeSourceInfo *T,
10035	bool IsPackExpansion);
10036
10037	/// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular
10038	/// declaration.
10039	void AddAssumeAlignedAttr(Decl D, const* AttributeCommonInfo &CI, Expr *E,
10040	Expr *OE);
10041
10042	/// AddAllocAlignAttr - Adds an alloc_align attribute to a particular
10043	/// declaration.
10044	void AddAllocAlignAttr(Decl D, const* AttributeCommonInfo &CI,
10045	Expr *ParamExpr);
10046
10047	/// AddAlignValueAttr - Adds an align_value attribute to a particular
10048	/// declaration.
10049	void AddAlignValueAttr(Decl D, const* AttributeCommonInfo &CI, Expr *E);
10050
10051	/// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.
10052	void AddAnnotationAttr(Decl D, const* AttributeCommonInfo &CI,
10053	StringRef Annot, MutableArrayRef<Expr *> Args);
10054
10055	/// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
10056	/// declaration.
10057	void AddLaunchBoundsAttr(Decl D, const* AttributeCommonInfo &CI,
10058	Expr MaxThreads, Expr MinBlocks);
10059
10060	/// AddModeAttr - Adds a mode attribute to a particular declaration.
10061	void AddModeAttr(Decl D, const* AttributeCommonInfo &CI, IdentifierInfo *Name,
10062	bool InInstantiation = false);
10063
10064	void AddParameterABIAttr(Decl D, const* AttributeCommonInfo &CI,
10065	ParameterABI ABI);
10066
10067	enum class RetainOwnershipKind {NS, CF, OS};
10068	void AddXConsumedAttr(Decl D, const* AttributeCommonInfo &CI,
10069	RetainOwnershipKind K, bool IsTemplateInstantiation);
10070
10071	/// addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size
10072	/// attribute to a particular declaration.
10073	void addAMDGPUFlatWorkGroupSizeAttr(Decl D, const* AttributeCommonInfo &CI,
10074	Expr Min, Expr Max);
10075
10076	/// addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a
10077	/// particular declaration.
10078	void addAMDGPUWavesPerEUAttr(Decl D, const* AttributeCommonInfo &CI,
10079	Expr Min, Expr Max);
10080
10081	bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
10082
10083	//===--------------------------------------------------------------------===//
10084	// C++ Coroutines TS
10085	//
10086	bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,
10087	StringRef Keyword);
10088	ExprResult ActOnCoawaitExpr(Scope S, SourceLocation KwLoc, Expr E);
10089	ExprResult ActOnCoyieldExpr(Scope S, SourceLocation KwLoc, Expr E);
10090	StmtResult ActOnCoreturnStmt(Scope S, SourceLocation KwLoc, Expr E);
10091
10092	ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
10093	bool IsImplicit = false);
10094	ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
10095	UnresolvedLookupExpr* Lookup);
10096	ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
10097	StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
10098	bool IsImplicit = false);
10099	StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);
10100	bool buildCoroutineParameterMoves(SourceLocation Loc);
10101	VarDecl *buildCoroutinePromise(SourceLocation Loc);
10102	void CheckCompletedCoroutineBody(FunctionDecl FD, Stmt &Body);
10103	ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc,
10104	SourceLocation FuncLoc);
10105	/// Check that the expression co_await promise.final_suspend() shall not be
10106	/// potentially-throwing.
10107	bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend);
10108
10109	//===--------------------------------------------------------------------===//
10110	// OpenCL extensions.
10111	//
10112	private:
10113	std::string CurrOpenCLExtension;
10114	/// Extensions required by an OpenCL type.
10115	llvm::DenseMap<const Type*, std::set<std::string>> OpenCLTypeExtMap;
10116	/// Extensions required by an OpenCL declaration.
10117	llvm::DenseMap<const Decl*, std::set<std::string>> OpenCLDeclExtMap;
10118	public:
10119	llvm::StringRef getCurrentOpenCLExtension() const {
10120	return CurrOpenCLExtension;
10121	}
10122
10123	/// Check if a function declaration \p FD associates with any
10124	/// extensions present in OpenCLDeclExtMap and if so return the
10125	/// extension(s) name(s).
10126	std::string getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD);
10127
10128	/// Check if a function type \p FT associates with any
10129	/// extensions present in OpenCLTypeExtMap and if so return the
10130	/// extension(s) name(s).
10131	std::string getOpenCLExtensionsFromTypeExtMap(FunctionType *FT);
10132
10133	/// Find an extension in an appropriate extension map and return its name
10134	template<typename T, typename MapT>
10135	std::string getOpenCLExtensionsFromExtMap(T* FT, MapT &Map);
10136
10137	void setCurrentOpenCLExtension(llvm::StringRef Ext) {
10138	CurrOpenCLExtension = std::string(Ext);
10139	}
10140
10141	/// Set OpenCL extensions for a type which can only be used when these
10142	/// OpenCL extensions are enabled. If \p Exts is empty, do nothing.
10143	/// \param Exts A space separated list of OpenCL extensions.
10144	void setOpenCLExtensionForType(QualType T, llvm::StringRef Exts);
10145
10146	/// Set OpenCL extensions for a declaration which can only be
10147	/// used when these OpenCL extensions are enabled. If \p Exts is empty, do
10148	/// nothing.
10149	/// \param Exts A space separated list of OpenCL extensions.
10150	void setOpenCLExtensionForDecl(Decl *FD, llvm::StringRef Exts);
10151
10152	/// Set current OpenCL extensions for a type which can only be used
10153	/// when these OpenCL extensions are enabled. If current OpenCL extension is
10154	/// empty, do nothing.
10155	void setCurrentOpenCLExtensionForType(QualType T);
10156
10157	/// Set current OpenCL extensions for a declaration which
10158	/// can only be used when these OpenCL extensions are enabled. If current
10159	/// OpenCL extension is empty, do nothing.
10160	void setCurrentOpenCLExtensionForDecl(Decl *FD);
10161
10162	bool isOpenCLDisabledDecl(Decl *FD);
10163
10164	/// Check if type \p T corresponding to declaration specifier \p DS
10165	/// is disabled due to required OpenCL extensions being disabled. If so,
10166	/// emit diagnostics.
10167	/// \return true if type is disabled.
10168	bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T);
10169
10170	/// Check if declaration \p D used by expression \p E
10171	/// is disabled due to required OpenCL extensions being disabled. If so,
10172	/// emit diagnostics.
10173	/// \return true if type is disabled.
10174	bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E);
10175
10176	//===--------------------------------------------------------------------===//
10177	// OpenMP directives and clauses.
10178	//
10179	private:
10180	void *VarDataSharingAttributesStack;
10181	/// Number of nested '#pragma omp declare target' directives.
10182	SmallVector<SourceLocation, `4`> DeclareTargetNesting;
10183	/// Initialization of data-sharing attributes stack.
10184	void InitDataSharingAttributesStack();
10185	void DestroyDataSharingAttributesStack();
10186	ExprResult
10187	VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind,
10188	bool StrictlyPositive = true);
10189	/// Returns OpenMP nesting level for current directive.
10190	unsigned getOpenMPNestingLevel() const;
10191
10192	/// Adjusts the function scopes index for the target-based regions.
10193	void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,
10194	unsigned Level) const;
10195
10196	/// Returns the number of scopes associated with the construct on the given
10197	/// OpenMP level.
10198	int getNumberOfConstructScopes(unsigned Level) const;
10199
10200	/// Push new OpenMP function region for non-capturing function.
10201	void pushOpenMPFunctionRegion();
10202
10203	/// Pop OpenMP function region for non-capturing function.
10204	void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI);
10205
10206	/// Checks if a type or a declaration is disabled due to the owning extension
10207	/// being disabled, and emits diagnostic messages if it is disabled.
10208	/// \param D type or declaration to be checked.
10209	/// \param DiagLoc source location for the diagnostic message.
10210	/// \param DiagInfo information to be emitted for the diagnostic message.
10211	/// \param SrcRange source range of the declaration.
10212	/// \param Map maps type or declaration to the extensions.
10213	/// \param Selector selects diagnostic message: 0 for type and 1 for
10214	/// declaration.
10215	/// \return true if the type or declaration is disabled.
10216	template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
10217	bool checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc, DiagInfoT DiagInfo,
10218	MapT &Map, unsigned Selector = `0`,
10219	SourceRange SrcRange = SourceRange ());
10220
10221	/// Helper to keep information about the current `omp begin/end declare
10222	/// variant` nesting.
10223	struct OMPDeclareVariantScope {
10224	/// The associated OpenMP context selector.
10225	OMPTraitInfo *TI;
10226
10227	/// The associated OpenMP context selector mangling.
10228	std::string NameSuffix;
10229
10230	OMPDeclareVariantScope(OMPTraitInfo &TI);
10231	};
10232
10233	/// Return the OMPTraitInfo for the surrounding scope, if any.
10234	OMPTraitInfo *getOMPTraitInfoForSurroundingScope() {
10235	return OMPDeclareVariantScopes.empty() ? nullptr
10236	: OMPDeclareVariantScopes.back().TI;
10237	}
10238
10239	/// The current `omp begin/end declare variant` scopes.
10240	SmallVector<OMPDeclareVariantScope, `4`> OMPDeclareVariantScopes;
10241
10242	/// The current `omp begin/end assumes` scopes.
10243	SmallVector<AssumptionAttr *, `4`> OMPAssumeScoped;
10244
10245	/// All `omp assumes` we encountered so far.
10246	SmallVector<AssumptionAttr *, `4`> OMPAssumeGlobal;
10247
10248	public:
10249	/// The declarator \p D defines a function in the scope \p S which is nested
10250	/// in an `omp begin/end declare variant` scope. In this method we create a
10251	/// declaration for \p D and rename \p D according to the OpenMP context
10252	/// selector of the surrounding scope. Return all base functions in \p Bases.
10253	void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(
10254	Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists,
10255	SmallVectorImpl<FunctionDecl *> &Bases);
10256
10257	/// Register \p D as specialization of all base functions in \p Bases in the
10258	/// current `omp begin/end declare variant` scope.
10259	void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(
10260	Decl D, SmallVectorImpl<FunctionDecl > &Bases);
10261
10262	/// Act on \p D, a function definition inside of an `omp [begin/end] assumes`.
10263	void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D);
10264
10265	/// Can we exit an OpenMP declare variant scope at the moment.
10266	bool isInOpenMPDeclareVariantScope() const {
10267	return !OMPDeclareVariantScopes.empty();
10268	}
10269
10270	/// Given the potential call expression \p Call, determine if there is a
10271	/// specialization via the OpenMP declare variant mechanism available. If
10272	/// there is, return the specialized call expression, otherwise return the
10273	/// original \p Call.
10274	ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope,
10275	SourceLocation LParenLoc, MultiExprArg ArgExprs,
10276	SourceLocation RParenLoc, Expr *ExecConfig);
10277
10278	/// Handle a `omp begin declare variant`.
10279	void ActOnOpenMPBeginDeclareVariant(SourceLocation Loc, OMPTraitInfo &TI);
10280
10281	/// Handle a `omp end declare variant`.
10282	void ActOnOpenMPEndDeclareVariant();
10283
10284	/// Checks if the variant/multiversion functions are compatible.
10285	bool areMultiversionVariantFunctionsCompatible(
10286	const FunctionDecl OldFD, const* FunctionDecl *NewFD,
10287	const PartialDiagnostic &NoProtoDiagID,
10288	const PartialDiagnosticAt &NoteCausedDiagIDAt,
10289	const PartialDiagnosticAt &NoSupportDiagIDAt,
10290	const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported,
10291	bool ConstexprSupported, bool CLinkageMayDiffer);
10292
10293	/// Function tries to capture lambda's captured variables in the OpenMP region
10294	/// before the original lambda is captured.
10295	void tryCaptureOpenMPLambdas(ValueDecl *V);
10296
10297	/// Return true if the provided declaration \a VD should be captured by
10298	/// reference.
10299	/// \param Level Relative level of nested OpenMP construct for that the check
10300	/// is performed.
10301	/// \param OpenMPCaptureLevel Capture level within an OpenMP construct.
10302	bool isOpenMPCapturedByRef(const ValueDecl D, unsigned* Level,
10303	unsigned OpenMPCaptureLevel) const;
10304
10305	/// Check if the specified variable is used in one of the private
10306	/// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP
10307	/// constructs.
10308	VarDecl isOpenMPCapturedDecl(ValueDecl D, bool CheckScopeInfo = false,
10309	unsigned StopAt = `0`);
10310	ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
10311	ExprObjectKind OK, SourceLocation Loc);
10312
10313	/// If the current region is a loop-based region, mark the start of the loop
10314	/// construct.
10315	void startOpenMPLoop();
10316
10317	/// If the current region is a range loop-based region, mark the start of the
10318	/// loop construct.
10319	void startOpenMPCXXRangeFor();
10320
10321	/// Check if the specified variable is used in 'private' clause.
10322	/// \param Level Relative level of nested OpenMP construct for that the check
10323	/// is performed.
10324	OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl D, unsigned* Level,
10325	unsigned CapLevel) const;
10326
10327	/// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.)
10328	/// for \p FD based on DSA for the provided corresponding captured declaration
10329	/// \p D.
10330	void setOpenMPCaptureKind(FieldDecl FD, const* ValueDecl D, unsigned* Level);
10331
10332	/// Check if the specified variable is captured by 'target' directive.
10333	/// \param Level Relative level of nested OpenMP construct for that the check
10334	/// is performed.
10335	bool isOpenMPTargetCapturedDecl(const ValueDecl D, unsigned* Level,
10336	unsigned CaptureLevel) const;
10337
10338	/// Check if the specified global variable must be captured by outer capture
10339	/// regions.
10340	/// \param Level Relative level of nested OpenMP construct for that
10341	/// the check is performed.
10342	bool isOpenMPGlobalCapturedDecl(ValueDecl D, unsigned* Level,
10343	unsigned CaptureLevel) const;
10344
10345	ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc,
10346	Expr *Op);
10347	/// Called on start of new data sharing attribute block.
10348	void StartOpenMPDSABlock(OpenMPDirectiveKind K,
10349	const DeclarationNameInfo &DirName, Scope *CurScope,
10350	SourceLocation Loc);
10351	/// Start analysis of clauses.
10352	void StartOpenMPClause(OpenMPClauseKind K);
10353	/// End analysis of clauses.
10354	void EndOpenMPClause();
10355	/// Called on end of data sharing attribute block.
10356	void EndOpenMPDSABlock(Stmt *CurDirective);
10357
10358	/// Check if the current region is an OpenMP loop region and if it is,
10359	/// mark loop control variable, used in \p Init for loop initialization, as
10360	/// private by default.
10361	/// \param Init First part of the for loop.
10362	void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);
10363
10364	// OpenMP directives and clauses.
10365	/// Called on correct id-expression from the '#pragma omp
10366	/// threadprivate'.
10367	ExprResult ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec,
10368	const DeclarationNameInfo &Id,
10369	OpenMPDirectiveKind Kind);
10370	/// Called on well-formed '#pragma omp threadprivate'.
10371	DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(
10372	SourceLocation Loc,
10373	ArrayRef<Expr *> VarList);
10374	/// Builds a new OpenMPThreadPrivateDecl and checks its correctness.
10375	OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(SourceLocation Loc,
10376	ArrayRef<Expr *> VarList);
10377	/// Called on well-formed '#pragma omp allocate'.
10378	DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc,
10379	ArrayRef<Expr *> VarList,
10380	ArrayRef<OMPClause *> Clauses,
10381	DeclContext Owner = nullptr*);
10382
10383	/// Called on well-formed '#pragma omp [begin] assume[s]'.
10384	void ActOnOpenMPAssumesDirective(SourceLocation Loc,
10385	OpenMPDirectiveKind DKind,
10386	ArrayRef<StringRef> Assumptions,
10387	bool SkippedClauses);
10388
10389	/// Check if there is an active global `omp begin assumes` directive.
10390	bool isInOpenMPAssumeScope() const { return !OMPAssumeScoped.empty(); }
10391
10392	/// Check if there is an active global `omp assumes` directive.
10393	bool hasGlobalOpenMPAssumes() const { return !OMPAssumeGlobal.empty(); }
10394
10395	/// Called on well-formed '#pragma omp end assumes'.
10396	void ActOnOpenMPEndAssumesDirective();
10397
10398	/// Called on well-formed '#pragma omp requires'.
10399	DeclGroupPtrTy ActOnOpenMPRequiresDirective(SourceLocation Loc,
10400	ArrayRef<OMPClause *> ClauseList);
10401	/// Check restrictions on Requires directive
10402	OMPRequiresDecl *CheckOMPRequiresDecl(SourceLocation Loc,
10403	ArrayRef<OMPClause *> Clauses);
10404	/// Check if the specified type is allowed to be used in 'omp declare
10405	/// reduction' construct.
10406	QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
10407	TypeResult ParsedType);
10408	/// Called on start of '#pragma omp declare reduction'.
10409	DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(
10410	Scope S, DeclContext DC, DeclarationName Name,
10411	ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
10412	AccessSpecifier AS, Decl PrevDeclInScope = nullptr*);
10413	/// Initialize declare reduction construct initializer.
10414	void ActOnOpenMPDeclareReductionCombinerStart(Scope S, Decl D);
10415	/// Finish current declare reduction construct initializer.
10416	void ActOnOpenMPDeclareReductionCombinerEnd(Decl D, Expr Combiner);
10417	/// Initialize declare reduction construct initializer.
10418	/// \return omp_priv variable.
10419	VarDecl ActOnOpenMPDeclareReductionInitializerStart(Scope S, Decl *D);
10420	/// Finish current declare reduction construct initializer.
10421	void ActOnOpenMPDeclareReductionInitializerEnd(Decl D, Expr Initializer,
10422	VarDecl *OmpPrivParm);
10423	/// Called at the end of '#pragma omp declare reduction'.
10424	DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(
10425	Scope S, DeclGroupPtrTy DeclReductions, bool* IsValid);
10426
10427	/// Check variable declaration in 'omp declare mapper' construct.
10428	TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D);
10429	/// Check if the specified type is allowed to be used in 'omp declare
10430	/// mapper' construct.
10431	QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc,
10432	TypeResult ParsedType);
10433	/// Called on start of '#pragma omp declare mapper'.
10434	DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(
10435	Scope S, DeclContext DC, DeclarationName Name, QualType MapperType,
10436	SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS,
10437	Expr MapperVarRef, ArrayRef<OMPClause > Clauses,
10438	Decl PrevDeclInScope = nullptr*);
10439	/// Build the mapper variable of '#pragma omp declare mapper'.
10440	ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S,
10441	QualType MapperType,
10442	SourceLocation StartLoc,
10443	DeclarationName VN);
10444	bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl VD) const*;
10445	const ValueDecl getOpenMPDeclareMapperVarName() const*;
10446
10447	/// Called on the start of target region i.e. '#pragma omp declare target'.
10448	bool ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc);
10449	/// Called at the end of target region i.e. '#pragme omp end declare target'.
10450	void ActOnFinishOpenMPDeclareTargetDirective();
10451	/// Searches for the provided declaration name for OpenMP declare target
10452	/// directive.
10453	NamedDecl *
10454	lookupOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec,
10455	const DeclarationNameInfo &Id,
10456	NamedDeclSetType &SameDirectiveDecls);
10457	/// Called on correct id-expression from the '#pragma omp declare target'.
10458	void ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc,
10459	OMPDeclareTargetDeclAttr::MapTypeTy MT,
10460	OMPDeclareTargetDeclAttr::DevTypeTy DT);
10461	/// Check declaration inside target region.
10462	void
10463	checkDeclIsAllowedInOpenMPTarget(Expr E, Decl D,
10464	SourceLocation IdLoc = SourceLocation ());
10465	/// Finishes analysis of the deferred functions calls that may be declared as
10466	/// host/nohost during device/host compilation.
10467	void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller,
10468	const FunctionDecl *Callee,
10469	SourceLocation Loc);
10470	/// Return true inside OpenMP declare target region.
10471	bool isInOpenMPDeclareTargetContext() const {
10472	return !DeclareTargetNesting.empty();
10473	}
10474	/// Return true inside OpenMP target region.
10475	bool isInOpenMPTargetExecutionDirective() const;
10476
10477	/// Return the number of captured regions created for an OpenMP directive.
10478	static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind);
10479
10480	/// Initialization of captured region for OpenMP region.
10481	void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope);
10482	/// End of OpenMP region.
10483	///
10484	/// \param S Statement associated with the current OpenMP region.
10485	/// \param Clauses List of clauses for the current OpenMP region.
10486	///
10487	/// \returns Statement for finished OpenMP region.
10488	StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
10489	StmtResult ActOnOpenMPExecutableDirective(
10490	OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
10491	OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
10492	Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
10493	/// Called on well-formed '\#pragma omp parallel' after parsing
10494	/// of the associated statement.
10495	StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
10496	Stmt *AStmt,
10497	SourceLocation StartLoc,
10498	SourceLocation EndLoc);
10499	using VarsWithInheritedDSAType =
10500	llvm::SmallDenseMap<const ValueDecl , const* Expr *, `4`>;
10501	/// Called on well-formed '\#pragma omp simd' after parsing
10502	/// of the associated statement.
10503	StmtResult
10504	ActOnOpenMPSimdDirective(ArrayRef<OMPClause > Clauses, Stmt AStmt,
10505	SourceLocation StartLoc, SourceLocation EndLoc,
10506	VarsWithInheritedDSAType &VarsWithImplicitDSA);
10507	/// Called on well-formed '\#pragma omp for' after parsing
10508	/// of the associated statement.
10509	StmtResult
10510	ActOnOpenMPForDirective(ArrayRef<OMPClause > Clauses, Stmt AStmt,
10511	SourceLocation StartLoc, SourceLocation EndLoc,
10512	VarsWithInheritedDSAType &VarsWithImplicitDSA);
10513	/// Called on well-formed '\#pragma omp for simd' after parsing
10514	/// of the associated statement.
10515	StmtResult
10516	ActOnOpenMPForSimdDirective(ArrayRef<OMPClause > Clauses, Stmt AStmt,
10517	SourceLocation StartLoc, SourceLocation EndLoc,
10518	VarsWithInheritedDSAType &VarsWithImplicitDSA);
10519	/// Called on well-formed '\#pragma omp sections' after parsing
10520	/// of the associated statement.
10521	StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
10522	Stmt *AStmt, SourceLocation StartLoc,
10523	SourceLocation EndLoc);
10524	/// Called on well-formed '\#pragma omp section' after parsing of the
10525	/// associated statement.
10526	StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
10527	SourceLocation EndLoc);
10528	/// Called on well-formed '\#pragma omp single' after parsing of the
10529	/// associated statement.
10530	StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
10531	Stmt *AStmt, SourceLocation StartLoc,
10532	SourceLocation EndLoc);
10533	/// Called on well-formed '\#pragma omp master' after parsing of the
10534	/// associated statement.
10535	StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,
10536	SourceLocation EndLoc);
10537	/// Called on well-formed '\#pragma omp critical' after parsing of the
10538	/// associated statement.
10539	StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName,
10540	ArrayRef<OMPClause *> Clauses,
10541	Stmt *AStmt, SourceLocation StartLoc,
10542	SourceLocation EndLoc);
10543	/// Called on well-formed '\#pragma omp parallel for' after parsing
10544	/// of the associated statement.
10545	StmtResult ActOnOpenMPParallelForDirective(
10546	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10547	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10548	/// Called on well-formed '\#pragma omp parallel for simd' after
10549	/// parsing of the associated statement.
10550	StmtResult ActOnOpenMPParallelForSimdDirective(
10551	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10552	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10553	/// Called on well-formed '\#pragma omp parallel master' after
10554	/// parsing of the associated statement.
10555	StmtResult ActOnOpenMPParallelMasterDirective(ArrayRef<OMPClause *> Clauses,
10556	Stmt *AStmt,
10557	SourceLocation StartLoc,
10558	SourceLocation EndLoc);
10559	/// Called on well-formed '\#pragma omp parallel sections' after
10560	/// parsing of the associated statement.
10561	StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
10562	Stmt *AStmt,
10563	SourceLocation StartLoc,
10564	SourceLocation EndLoc);
10565	/// Called on well-formed '\#pragma omp task' after parsing of the
10566	/// associated statement.
10567	StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
10568	Stmt *AStmt, SourceLocation StartLoc,
10569	SourceLocation EndLoc);
10570	/// Called on well-formed '\#pragma omp taskyield'.
10571	StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
10572	SourceLocation EndLoc);
10573	/// Called on well-formed '\#pragma omp barrier'.
10574	StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
10575	SourceLocation EndLoc);
10576	/// Called on well-formed '\#pragma omp taskwait'.
10577	StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
10578	SourceLocation EndLoc);
10579	/// Called on well-formed '\#pragma omp taskgroup'.
10580	StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses,
10581	Stmt *AStmt, SourceLocation StartLoc,
10582	SourceLocation EndLoc);
10583	/// Called on well-formed '\#pragma omp flush'.
10584	StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
10585	SourceLocation StartLoc,
10586	SourceLocation EndLoc);
10587	/// Called on well-formed '\#pragma omp depobj'.
10588	StmtResult ActOnOpenMPDepobjDirective(ArrayRef<OMPClause *> Clauses,
10589	SourceLocation StartLoc,
10590	SourceLocation EndLoc);
10591	/// Called on well-formed '\#pragma omp scan'.
10592	StmtResult ActOnOpenMPScanDirective(ArrayRef<OMPClause *> Clauses,
10593	SourceLocation StartLoc,
10594	SourceLocation EndLoc);
10595	/// Called on well-formed '\#pragma omp ordered' after parsing of the
10596	/// associated statement.
10597	StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
10598	Stmt *AStmt, SourceLocation StartLoc,
10599	SourceLocation EndLoc);
10600	/// Called on well-formed '\#pragma omp atomic' after parsing of the
10601	/// associated statement.
10602	StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
10603	Stmt *AStmt, SourceLocation StartLoc,
10604	SourceLocation EndLoc);
10605	/// Called on well-formed '\#pragma omp target' after parsing of the
10606	/// associated statement.
10607	StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
10608	Stmt *AStmt, SourceLocation StartLoc,
10609	SourceLocation EndLoc);
10610	/// Called on well-formed '\#pragma omp target data' after parsing of
10611	/// the associated statement.
10612	StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
10613	Stmt *AStmt, SourceLocation StartLoc,
10614	SourceLocation EndLoc);
10615	/// Called on well-formed '\#pragma omp target enter data' after
10616	/// parsing of the associated statement.
10617	StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
10618	SourceLocation StartLoc,
10619	SourceLocation EndLoc,
10620	Stmt *AStmt);
10621	/// Called on well-formed '\#pragma omp target exit data' after
10622	/// parsing of the associated statement.
10623	StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
10624	SourceLocation StartLoc,
10625	SourceLocation EndLoc,
10626	Stmt *AStmt);
10627	/// Called on well-formed '\#pragma omp target parallel' after
10628	/// parsing of the associated statement.
10629	StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
10630	Stmt *AStmt,
10631	SourceLocation StartLoc,
10632	SourceLocation EndLoc);
10633	/// Called on well-formed '\#pragma omp target parallel for' after
10634	/// parsing of the associated statement.
10635	StmtResult ActOnOpenMPTargetParallelForDirective(
10636	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10637	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10638	/// Called on well-formed '\#pragma omp teams' after parsing of the
10639	/// associated statement.
10640	StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
10641	Stmt *AStmt, SourceLocation StartLoc,
10642	SourceLocation EndLoc);
10643	/// Called on well-formed '\#pragma omp cancellation point'.
10644	StmtResult
10645	ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
10646	SourceLocation EndLoc,
10647	OpenMPDirectiveKind CancelRegion);
10648	/// Called on well-formed '\#pragma omp cancel'.
10649	StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
10650	SourceLocation StartLoc,
10651	SourceLocation EndLoc,
10652	OpenMPDirectiveKind CancelRegion);
10653	/// Called on well-formed '\#pragma omp taskloop' after parsing of the
10654	/// associated statement.
10655	StmtResult
10656	ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause > Clauses, Stmt AStmt,
10657	SourceLocation StartLoc, SourceLocation EndLoc,
10658	VarsWithInheritedDSAType &VarsWithImplicitDSA);
10659	/// Called on well-formed '\#pragma omp taskloop simd' after parsing of
10660	/// the associated statement.
10661	StmtResult ActOnOpenMPTaskLoopSimdDirective(
10662	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10663	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10664	/// Called on well-formed '\#pragma omp master taskloop' after parsing of the
10665	/// associated statement.
10666	StmtResult ActOnOpenMPMasterTaskLoopDirective(
10667	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10668	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10669	/// Called on well-formed '\#pragma omp master taskloop simd' after parsing of
10670	/// the associated statement.
10671	StmtResult ActOnOpenMPMasterTaskLoopSimdDirective(
10672	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10673	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10674	/// Called on well-formed '\#pragma omp parallel master taskloop' after
10675	/// parsing of the associated statement.
10676	StmtResult ActOnOpenMPParallelMasterTaskLoopDirective(
10677	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10678	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10679	/// Called on well-formed '\#pragma omp parallel master taskloop simd' after
10680	/// parsing of the associated statement.
10681	StmtResult ActOnOpenMPParallelMasterTaskLoopSimdDirective(
10682	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10683	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10684	/// Called on well-formed '\#pragma omp distribute' after parsing
10685	/// of the associated statement.
10686	StmtResult
10687	ActOnOpenMPDistributeDirective(ArrayRef<OMPClause > Clauses, Stmt AStmt,
10688	SourceLocation StartLoc, SourceLocation EndLoc,
10689	VarsWithInheritedDSAType &VarsWithImplicitDSA);
10690	/// Called on well-formed '\#pragma omp target update'.
10691	StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
10692	SourceLocation StartLoc,
10693	SourceLocation EndLoc,
10694	Stmt *AStmt);
10695	/// Called on well-formed '\#pragma omp distribute parallel for' after
10696	/// parsing of the associated statement.
10697	StmtResult ActOnOpenMPDistributeParallelForDirective(
10698	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10699	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10700	/// Called on well-formed '\#pragma omp distribute parallel for simd'
10701	/// after parsing of the associated statement.
10702	StmtResult ActOnOpenMPDistributeParallelForSimdDirective(
10703	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10704	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10705	/// Called on well-formed '\#pragma omp distribute simd' after
10706	/// parsing of the associated statement.
10707	StmtResult ActOnOpenMPDistributeSimdDirective(
10708	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10709	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10710	/// Called on well-formed '\#pragma omp target parallel for simd' after
10711	/// parsing of the associated statement.
10712	StmtResult ActOnOpenMPTargetParallelForSimdDirective(
10713	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10714	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10715	/// Called on well-formed '\#pragma omp target simd' after parsing of
10716	/// the associated statement.
10717	StmtResult
10718	ActOnOpenMPTargetSimdDirective(ArrayRef<OMPClause > Clauses, Stmt AStmt,
10719	SourceLocation StartLoc, SourceLocation EndLoc,
10720	VarsWithInheritedDSAType &VarsWithImplicitDSA);
10721	/// Called on well-formed '\#pragma omp teams distribute' after parsing of
10722	/// the associated statement.
10723	StmtResult ActOnOpenMPTeamsDistributeDirective(
10724	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10725	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10726	/// Called on well-formed '\#pragma omp teams distribute simd' after parsing
10727	/// of the associated statement.
10728	StmtResult ActOnOpenMPTeamsDistributeSimdDirective(
10729	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10730	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10731	/// Called on well-formed '\#pragma omp teams distribute parallel for simd'
10732	/// after parsing of the associated statement.
10733	StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective(
10734	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10735	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10736	/// Called on well-formed '\#pragma omp teams distribute parallel for'
10737	/// after parsing of the associated statement.
10738	StmtResult ActOnOpenMPTeamsDistributeParallelForDirective(
10739	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10740	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10741	/// Called on well-formed '\#pragma omp target teams' after parsing of the
10742	/// associated statement.
10743	StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
10744	Stmt *AStmt,
10745	SourceLocation StartLoc,
10746	SourceLocation EndLoc);
10747	/// Called on well-formed '\#pragma omp target teams distribute' after parsing
10748	/// of the associated statement.
10749	StmtResult ActOnOpenMPTargetTeamsDistributeDirective(
10750	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10751	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10752	/// Called on well-formed '\#pragma omp target teams distribute parallel for'
10753	/// after parsing of the associated statement.
10754	StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective(
10755	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10756	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10757	/// Called on well-formed '\#pragma omp target teams distribute parallel for
10758	/// simd' after parsing of the associated statement.
10759	StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
10760	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10761	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10762	/// Called on well-formed '\#pragma omp target teams distribute simd' after
10763	/// parsing of the associated statement.
10764	StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(
10765	ArrayRef<OMPClause > Clauses, Stmt AStmt, SourceLocation StartLoc,
10766	SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10767
10768	/// Checks correctness of linear modifiers.
10769	bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
10770	SourceLocation LinLoc);
10771	/// Checks that the specified declaration matches requirements for the linear
10772	/// decls.
10773	bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc,
10774	OpenMPLinearClauseKind LinKind, QualType Type,
10775	bool IsDeclareSimd = false);
10776
10777	/// Called on well-formed '\#pragma omp declare simd' after parsing of
10778	/// the associated method/function.
10779	DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(
10780	DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,
10781	Expr Simdlen, ArrayRef<Expr > Uniforms, ArrayRef<Expr *> Aligneds,
10782	ArrayRef<Expr > Alignments, ArrayRef<Expr > Linears,
10783	ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);
10784
10785	/// Checks '\#pragma omp declare variant' variant function and original
10786	/// functions after parsing of the associated method/function.
10787	/// \param DG Function declaration to which declare variant directive is
10788	/// applied to.
10789	/// \param VariantRef Expression that references the variant function, which
10790	/// must be used instead of the original one, specified in \p DG.
10791	/// \param TI The trait info object representing the match clause.
10792	/// \returns None, if the function/variant function are not compatible with
10793	/// the pragma, pair of original function/variant ref expression otherwise.
10794	Optional<std::pair<FunctionDecl , Expr >>
10795	checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef,
10796	OMPTraitInfo &TI, SourceRange SR);
10797
10798	/// Called on well-formed '\#pragma omp declare variant' after parsing of
10799	/// the associated method/function.
10800	/// \param FD Function declaration to which declare variant directive is
10801	/// applied to.
10802	/// \param VariantRef Expression that references the variant function, which
10803	/// must be used instead of the original one, specified in \p DG.
10804	/// \param TI The context traits associated with the function variant.
10805	void ActOnOpenMPDeclareVariantDirective(FunctionDecl FD, Expr VariantRef,
10806	OMPTraitInfo &TI, SourceRange SR);
10807
10808	OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
10809	Expr *Expr,
10810	SourceLocation StartLoc,
10811	SourceLocation LParenLoc,
10812	SourceLocation EndLoc);
10813	/// Called on well-formed 'allocator' clause.
10814	OMPClause ActOnOpenMPAllocatorClause(Expr Allocator,
10815	SourceLocation StartLoc,
10816	SourceLocation LParenLoc,
10817	SourceLocation EndLoc);
10818	/// Called on well-formed 'if' clause.
10819	OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
10820	Expr *Condition, SourceLocation StartLoc,
10821	SourceLocation LParenLoc,
10822	SourceLocation NameModifierLoc,
10823	SourceLocation ColonLoc,
10824	SourceLocation EndLoc);
10825	/// Called on well-formed 'final' clause.
10826	OMPClause ActOnOpenMPFinalClause(Expr Condition, SourceLocation StartLoc,
10827	SourceLocation LParenLoc,
10828	SourceLocation EndLoc);
10829	/// Called on well-formed 'num_threads' clause.
10830	OMPClause ActOnOpenMPNumThreadsClause(Expr NumThreads,
10831	SourceLocation StartLoc,
10832	SourceLocation LParenLoc,
10833	SourceLocation EndLoc);
10834	/// Called on well-formed 'safelen' clause.
10835	OMPClause ActOnOpenMPSafelenClause(Expr Length,
10836	SourceLocation StartLoc,
10837	SourceLocation LParenLoc,
10838	SourceLocation EndLoc);
10839	/// Called on well-formed 'simdlen' clause.
10840	OMPClause ActOnOpenMPSimdlenClause(Expr Length, SourceLocation StartLoc,
10841	SourceLocation LParenLoc,
10842	SourceLocation EndLoc);
10843	/// Called on well-formed 'collapse' clause.
10844	OMPClause ActOnOpenMPCollapseClause(Expr NumForLoops,
10845	SourceLocation StartLoc,
10846	SourceLocation LParenLoc,
10847	SourceLocation EndLoc);
10848	/// Called on well-formed 'ordered' clause.
10849	OMPClause *
10850	ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc,
10851	SourceLocation LParenLoc = SourceLocation (),
10852	Expr NumForLoops = nullptr*);
10853	/// Called on well-formed 'grainsize' clause.
10854	OMPClause ActOnOpenMPGrainsizeClause(Expr Size, SourceLocation StartLoc,
10855	SourceLocation LParenLoc,
10856	SourceLocation EndLoc);
10857	/// Called on well-formed 'num_tasks' clause.
10858	OMPClause ActOnOpenMPNumTasksClause(Expr NumTasks, SourceLocation StartLoc,
10859	SourceLocation LParenLoc,
10860	SourceLocation EndLoc);
10861	/// Called on well-formed 'hint' clause.
10862	OMPClause ActOnOpenMPHintClause(Expr Hint, SourceLocation StartLoc,
10863	SourceLocation LParenLoc,
10864	SourceLocation EndLoc);
10865	/// Called on well-formed 'detach' clause.
10866	OMPClause ActOnOpenMPDetachClause(Expr Evt, SourceLocation StartLoc,
10867	SourceLocation LParenLoc,
10868	SourceLocation EndLoc);
10869
10870	OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
10871	unsigned Argument,
10872	SourceLocation ArgumentLoc,
10873	SourceLocation StartLoc,
10874	SourceLocation LParenLoc,
10875	SourceLocation EndLoc);
10876	/// Called on well-formed 'default' clause.
10877	OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind,
10878	SourceLocation KindLoc,
10879	SourceLocation StartLoc,
10880	SourceLocation LParenLoc,
10881	SourceLocation EndLoc);
10882	/// Called on well-formed 'proc_bind' clause.
10883	OMPClause *ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind,
10884	SourceLocation KindLoc,
10885	SourceLocation StartLoc,
10886	SourceLocation LParenLoc,
10887	SourceLocation EndLoc);
10888	/// Called on well-formed 'order' clause.
10889	OMPClause *ActOnOpenMPOrderClause(OpenMPOrderClauseKind Kind,
10890	SourceLocation KindLoc,
10891	SourceLocation StartLoc,
10892	SourceLocation LParenLoc,
10893	SourceLocation EndLoc);
10894	/// Called on well-formed 'update' clause.
10895	OMPClause *ActOnOpenMPUpdateClause(OpenMPDependClauseKind Kind,
10896	SourceLocation KindLoc,
10897	SourceLocation StartLoc,
10898	SourceLocation LParenLoc,
10899	SourceLocation EndLoc);
10900
10901	OMPClause *ActOnOpenMPSingleExprWithArgClause(
10902	OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr,
10903	SourceLocation StartLoc, SourceLocation LParenLoc,
10904	ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc,
10905	SourceLocation EndLoc);
10906	/// Called on well-formed 'schedule' clause.
10907	OMPClause *ActOnOpenMPScheduleClause(
10908	OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
10909	OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
10910	SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
10911	SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc);
10912
10913	OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc,
10914	SourceLocation EndLoc);
10915	/// Called on well-formed 'nowait' clause.
10916	OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc,
10917	SourceLocation EndLoc);
10918	/// Called on well-formed 'untied' clause.
10919	OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc,
10920	SourceLocation EndLoc);
10921	/// Called on well-formed 'mergeable' clause.
10922	OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc,
10923	SourceLocation EndLoc);
10924	/// Called on well-formed 'read' clause.
10925	OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc,
10926	SourceLocation EndLoc);
10927	/// Called on well-formed 'write' clause.
10928	OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc,
10929	SourceLocation EndLoc);
10930	/// Called on well-formed 'update' clause.
10931	OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc,
10932	SourceLocation EndLoc);
10933	/// Called on well-formed 'capture' clause.
10934	OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc,
10935	SourceLocation EndLoc);
10936	/// Called on well-formed 'seq_cst' clause.
10937	OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
10938	SourceLocation EndLoc);
10939	/// Called on well-formed 'acq_rel' clause.
10940	OMPClause *ActOnOpenMPAcqRelClause(SourceLocation StartLoc,
10941	SourceLocation EndLoc);
10942	/// Called on well-formed 'acquire' clause.
10943	OMPClause *ActOnOpenMPAcquireClause(SourceLocation StartLoc,
10944	SourceLocation EndLoc);
10945	/// Called on well-formed 'release' clause.
10946	OMPClause *ActOnOpenMPReleaseClause(SourceLocation StartLoc,
10947	SourceLocation EndLoc);
10948	/// Called on well-formed 'relaxed' clause.
10949	OMPClause *ActOnOpenMPRelaxedClause(SourceLocation StartLoc,
10950	SourceLocation EndLoc);
10951	/// Called on well-formed 'destroy' clause.
10952	OMPClause *ActOnOpenMPDestroyClause(SourceLocation StartLoc,
10953	SourceLocation EndLoc);
10954	/// Called on well-formed 'threads' clause.
10955	OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,
10956	SourceLocation EndLoc);
10957	/// Called on well-formed 'simd' clause.
10958	OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,
10959	SourceLocation EndLoc);
10960	/// Called on well-formed 'nogroup' clause.
10961	OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc,
10962	SourceLocation EndLoc);
10963	/// Called on well-formed 'unified_address' clause.
10964	OMPClause *ActOnOpenMPUnifiedAddressClause(SourceLocation StartLoc,
10965	SourceLocation EndLoc);
10966
10967	/// Called on well-formed 'unified_address' clause.
10968	OMPClause *ActOnOpenMPUnifiedSharedMemoryClause(SourceLocation StartLoc,
10969	SourceLocation EndLoc);
10970
10971	/// Called on well-formed 'reverse_offload' clause.
10972	OMPClause *ActOnOpenMPReverseOffloadClause(SourceLocation StartLoc,
10973	SourceLocation EndLoc);
10974
10975	/// Called on well-formed 'dynamic_allocators' clause.
10976	OMPClause *ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc,
10977	SourceLocation EndLoc);
10978
10979	/// Called on well-formed 'atomic_default_mem_order' clause.
10980	OMPClause *ActOnOpenMPAtomicDefaultMemOrderClause(
10981	OpenMPAtomicDefaultMemOrderClauseKind Kind, SourceLocation KindLoc,
10982	SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
10983
10984	OMPClause *ActOnOpenMPVarListClause(
10985	OpenMPClauseKind Kind, ArrayRef<Expr > Vars, Expr DepModOrTailExpr,
10986	const OMPVarListLocTy &Locs, SourceLocation ColonLoc,
10987	CXXScopeSpec &ReductionOrMapperIdScopeSpec,
10988	DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier,
10989	ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
10990	ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit,
10991	SourceLocation ExtraModifierLoc,
10992	ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
10993	ArrayRef<SourceLocation> MotionModifiersLoc);
10994	/// Called on well-formed 'inclusive' clause.
10995	OMPClause ActOnOpenMPInclusiveClause(ArrayRef<Expr > VarList,
10996	SourceLocation StartLoc,
10997	SourceLocation LParenLoc,
10998	SourceLocation EndLoc);
10999	/// Called on well-formed 'exclusive' clause.
11000	OMPClause ActOnOpenMPExclusiveClause(ArrayRef<Expr > VarList,
11001	SourceLocation StartLoc,
11002	SourceLocation LParenLoc,
11003	SourceLocation EndLoc);
11004	/// Called on well-formed 'allocate' clause.
11005	OMPClause *
11006	ActOnOpenMPAllocateClause(Expr Allocator, ArrayRef<Expr > VarList,
11007	SourceLocation StartLoc, SourceLocation ColonLoc,
11008	SourceLocation LParenLoc, SourceLocation EndLoc);
11009	/// Called on well-formed 'private' clause.
11010	OMPClause ActOnOpenMPPrivateClause(ArrayRef<Expr > VarList,
11011	SourceLocation StartLoc,
11012	SourceLocation LParenLoc,
11013	SourceLocation EndLoc);
11014	/// Called on well-formed 'firstprivate' clause.
11015	OMPClause ActOnOpenMPFirstprivateClause(ArrayRef<Expr > VarList,
11016	SourceLocation StartLoc,
11017	SourceLocation LParenLoc,
11018	SourceLocation EndLoc);
11019	/// Called on well-formed 'lastprivate' clause.
11020	OMPClause *ActOnOpenMPLastprivateClause(
11021	ArrayRef<Expr *> VarList, OpenMPLastprivateModifier LPKind,
11022	SourceLocation LPKindLoc, SourceLocation ColonLoc,
11023	SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
11024	/// Called on well-formed 'shared' clause.
11025	OMPClause ActOnOpenMPSharedClause(ArrayRef<Expr > VarList,
11026	SourceLocation StartLoc,
11027	SourceLocation LParenLoc,
11028	SourceLocation EndLoc);
11029	/// Called on well-formed 'reduction' clause.
11030	OMPClause *ActOnOpenMPReductionClause(
11031	ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
11032	SourceLocation StartLoc, SourceLocation LParenLoc,
11033	SourceLocation ModifierLoc, SourceLocation ColonLoc,
11034	SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
11035	const DeclarationNameInfo &ReductionId,
11036	ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11037	/// Called on well-formed 'task_reduction' clause.
11038	OMPClause *ActOnOpenMPTaskReductionClause(
11039	ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11040	SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
11041	CXXScopeSpec &ReductionIdScopeSpec,
11042	const DeclarationNameInfo &ReductionId,
11043	ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11044	/// Called on well-formed 'in_reduction' clause.
11045	OMPClause *ActOnOpenMPInReductionClause(
11046	ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11047	SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
11048	CXXScopeSpec &ReductionIdScopeSpec,
11049	const DeclarationNameInfo &ReductionId,
11050	ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11051	/// Called on well-formed 'linear' clause.
11052	OMPClause *
11053	ActOnOpenMPLinearClause(ArrayRef<Expr > VarList, Expr Step,
11054	SourceLocation StartLoc, SourceLocation LParenLoc,
11055	OpenMPLinearClauseKind LinKind, SourceLocation LinLoc,
11056	SourceLocation ColonLoc, SourceLocation EndLoc);
11057	/// Called on well-formed 'aligned' clause.
11058	OMPClause ActOnOpenMPAlignedClause(ArrayRef<Expr > VarList,
11059	Expr *Alignment,
11060	SourceLocation StartLoc,
11061	SourceLocation LParenLoc,
11062	SourceLocation ColonLoc,
11063	SourceLocation EndLoc);
11064	/// Called on well-formed 'copyin' clause.
11065	OMPClause ActOnOpenMPCopyinClause(ArrayRef<Expr > VarList,
11066	SourceLocation StartLoc,
11067	SourceLocation LParenLoc,
11068	SourceLocation EndLoc);
11069	/// Called on well-formed 'copyprivate' clause.
11070	OMPClause ActOnOpenMPCopyprivateClause(ArrayRef<Expr > VarList,
11071	SourceLocation StartLoc,
11072	SourceLocation LParenLoc,
11073	SourceLocation EndLoc);
11074	/// Called on well-formed 'flush' pseudo clause.
11075	OMPClause ActOnOpenMPFlushClause(ArrayRef<Expr > VarList,
11076	SourceLocation StartLoc,
11077	SourceLocation LParenLoc,
11078	SourceLocation EndLoc);
11079	/// Called on well-formed 'depobj' pseudo clause.
11080	OMPClause ActOnOpenMPDepobjClause(Expr Depobj, SourceLocation StartLoc,
11081	SourceLocation LParenLoc,
11082	SourceLocation EndLoc);
11083	/// Called on well-formed 'depend' clause.
11084	OMPClause *
11085	ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
11086	SourceLocation DepLoc, SourceLocation ColonLoc,
11087	ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11088	SourceLocation LParenLoc, SourceLocation EndLoc);
11089	/// Called on well-formed 'device' clause.
11090	OMPClause *ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
11091	Expr *Device, SourceLocation StartLoc,
11092	SourceLocation LParenLoc,
11093	SourceLocation ModifierLoc,
11094	SourceLocation EndLoc);
11095	/// Called on well-formed 'map' clause.
11096	OMPClause *
11097	ActOnOpenMPMapClause(ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
11098	ArrayRef<SourceLocation> MapTypeModifiersLoc,
11099	CXXScopeSpec &MapperIdScopeSpec,
11100	DeclarationNameInfo &MapperId,
11101	OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
11102	SourceLocation MapLoc, SourceLocation ColonLoc,
11103	ArrayRef<Expr > VarList, const* OMPVarListLocTy &Locs,
11104	ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11105	/// Called on well-formed 'num_teams' clause.
11106	OMPClause ActOnOpenMPNumTeamsClause(Expr NumTeams, SourceLocation StartLoc,
11107	SourceLocation LParenLoc,
11108	SourceLocation EndLoc);
11109	/// Called on well-formed 'thread_limit' clause.
11110	OMPClause ActOnOpenMPThreadLimitClause(Expr ThreadLimit,
11111	SourceLocation StartLoc,
11112	SourceLocation LParenLoc,
11113	SourceLocation EndLoc);
11114	/// Called on well-formed 'priority' clause.
11115	OMPClause ActOnOpenMPPriorityClause(Expr Priority, SourceLocation StartLoc,
11116	SourceLocation LParenLoc,
11117	SourceLocation EndLoc);
11118	/// Called on well-formed 'dist_schedule' clause.
11119	OMPClause *ActOnOpenMPDistScheduleClause(
11120	OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
11121	SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc,
11122	SourceLocation CommaLoc, SourceLocation EndLoc);
11123	/// Called on well-formed 'defaultmap' clause.
11124	OMPClause *ActOnOpenMPDefaultmapClause(
11125	OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
11126	SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
11127	SourceLocation KindLoc, SourceLocation EndLoc);
11128	/// Called on well-formed 'to' clause.
11129	OMPClause *
11130	ActOnOpenMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11131	ArrayRef<SourceLocation> MotionModifiersLoc,
11132	CXXScopeSpec &MapperIdScopeSpec,
11133	DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
11134	ArrayRef<Expr > VarList, const* OMPVarListLocTy &Locs,
11135	ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11136	/// Called on well-formed 'from' clause.
11137	OMPClause *
11138	ActOnOpenMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11139	ArrayRef<SourceLocation> MotionModifiersLoc,
11140	CXXScopeSpec &MapperIdScopeSpec,
11141	DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
11142	ArrayRef<Expr > VarList, const* OMPVarListLocTy &Locs,
11143	ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11144	/// Called on well-formed 'use_device_ptr' clause.
11145	OMPClause ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr > VarList,
11146	const OMPVarListLocTy &Locs);
11147	/// Called on well-formed 'use_device_addr' clause.
11148	OMPClause ActOnOpenMPUseDeviceAddrClause(ArrayRef<Expr > VarList,
11149	const OMPVarListLocTy &Locs);
11150	/// Called on well-formed 'is_device_ptr' clause.
11151	OMPClause ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr > VarList,
11152	const OMPVarListLocTy &Locs);
11153	/// Called on well-formed 'nontemporal' clause.
11154	OMPClause ActOnOpenMPNontemporalClause(ArrayRef<Expr > VarList,
11155	SourceLocation StartLoc,
11156	SourceLocation LParenLoc,
11157	SourceLocation EndLoc);
11158
11159	/// Data for list of allocators.
11160	struct UsesAllocatorsData {
11161	/// Allocator.
11162	Expr Allocator = nullptr*;
11163	/// Allocator traits.
11164	Expr AllocatorTraits = nullptr*;
11165	/// Locations of '(' and ')' symbols.
11166	SourceLocation LParenLoc, RParenLoc;
11167	};
11168	/// Called on well-formed 'uses_allocators' clause.
11169	OMPClause *ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc,
11170	SourceLocation LParenLoc,
11171	SourceLocation EndLoc,
11172	ArrayRef<UsesAllocatorsData> Data);
11173	/// Called on well-formed 'affinity' clause.
11174	OMPClause *ActOnOpenMPAffinityClause(SourceLocation StartLoc,
11175	SourceLocation LParenLoc,
11176	SourceLocation ColonLoc,
11177	SourceLocation EndLoc, Expr *Modifier,
11178	ArrayRef<Expr *> Locators);
11179
11180	/// The kind of conversion being performed.
11181	enum CheckedConversionKind {
11182	/// An implicit conversion.
11183	CCK_ImplicitConversion,
11184	/// A C-style cast.
11185	CCK_CStyleCast,
11186	/// A functional-style cast.
11187	CCK_FunctionalCast,
11188	/// A cast other than a C-style cast.
11189	CCK_OtherCast,
11190	/// A conversion for an operand of a builtin overloaded operator.
11191	CCK_ForBuiltinOverloadedOp
11192	};
11193
11194	static bool isCast(CheckedConversionKind CCK) {
11195	return CCK == CCK_CStyleCast \|\| CCK == CCK_FunctionalCast \|\|
11196	CCK == CCK_OtherCast;
11197	}
11198
11199	/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
11200	/// cast. If there is already an implicit cast, merge into the existing one.
11201	/// If isLvalue, the result of the cast is an lvalue.
11202	ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
11203	ExprValueKind VK = VK_RValue,
11204	const CXXCastPath BasePath = nullptr*,
11205	CheckedConversionKind CCK
11206	= CCK_ImplicitConversion);
11207
11208	/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
11209	/// to the conversion from scalar type ScalarTy to the Boolean type.
11210	static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy);
11211
11212	/// IgnoredValueConversions - Given that an expression's result is
11213	/// syntactically ignored, perform any conversions that are
11214	/// required.
11215	ExprResult IgnoredValueConversions(Expr *E);
11216
11217	// UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
11218	// functions and arrays to their respective pointers (C99 6.3.2.1).
11219	ExprResult UsualUnaryConversions(Expr *E);
11220
11221	/// CallExprUnaryConversions - a special case of an unary conversion
11222	/// performed on a function designator of a call expression.
11223	ExprResult CallExprUnaryConversions(Expr *E);
11224
11225	// DefaultFunctionArrayConversion - converts functions and arrays
11226	// to their respective pointers (C99 6.3.2.1).
11227	ExprResult DefaultFunctionArrayConversion(Expr E, bool* Diagnose = true);
11228
11229	// DefaultFunctionArrayLvalueConversion - converts functions and
11230	// arrays to their respective pointers and performs the
11231	// lvalue-to-rvalue conversion.
11232	ExprResult DefaultFunctionArrayLvalueConversion(Expr *E,
11233	bool Diagnose = true);
11234
11235	// DefaultLvalueConversion - performs lvalue-to-rvalue conversion on
11236	// the operand. This function is a no-op if the operand has a function type
11237	// or an array type.
11238	ExprResult DefaultLvalueConversion(Expr *E);
11239
11240	// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
11241	// do not have a prototype. Integer promotions are performed on each
11242	// argument, and arguments that have type float are promoted to double.
11243	ExprResult DefaultArgumentPromotion(Expr *E);
11244
11245	/// If \p E is a prvalue denoting an unmaterialized temporary, materialize
11246	/// it as an xvalue. In C++98, the result will still be a prvalue, because
11247	/// we don't have xvalues there.
11248	ExprResult TemporaryMaterializationConversion(Expr *E);
11249
11250	// Used for emitting the right warning by DefaultVariadicArgumentPromotion
11251	enum VariadicCallType {
11252	VariadicFunction,
11253	VariadicBlock,
11254	VariadicMethod,
11255	VariadicConstructor,
11256	VariadicDoesNotApply
11257	};
11258
11259	VariadicCallType getVariadicCallType(FunctionDecl *FDecl,
11260	const FunctionProtoType *Proto,
11261	Expr *Fn);
11262
11263	// Used for determining in which context a type is allowed to be passed to a
11264	// vararg function.
11265	enum VarArgKind {
11266	VAK_Valid,
11267	VAK_ValidInCXX11,
11268	VAK_Undefined,
11269	VAK_MSVCUndefined,
11270	VAK_Invalid
11271	};
11272
11273	// Determines which VarArgKind fits an expression.
11274	VarArgKind isValidVarArgType(const QualType &Ty);
11275
11276	/// Check to see if the given expression is a valid argument to a variadic
11277	/// function, issuing a diagnostic if not.
11278	void checkVariadicArgument(const Expr *E, VariadicCallType CT);
11279
11280	/// Check to see if a given expression could have '.c_str()' called on it.
11281	bool hasCStrMethod(const Expr *E);
11282
11283	/// GatherArgumentsForCall - Collector argument expressions for various
11284	/// form of call prototypes.
11285	bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
11286	const FunctionProtoType *Proto,
11287	unsigned FirstParam, ArrayRef<Expr *> Args,
11288	SmallVectorImpl<Expr *> &AllArgs,
11289	VariadicCallType CallType = VariadicDoesNotApply,
11290	bool AllowExplicit = false,
11291	bool IsListInitialization = false);
11292
11293	// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
11294	// will create a runtime trap if the resulting type is not a POD type.
11295	ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
11296	FunctionDecl *FDecl);
11297
11298	/// Context in which we're performing a usual arithmetic conversion.
11299	enum ArithConvKind {
11300	/// An arithmetic operation.
11301	ACK_Arithmetic,
11302	/// A bitwise operation.
11303	ACK_BitwiseOp,
11304	/// A comparison.
11305	ACK_Comparison,
11306	/// A conditional (?:) operator.
11307	ACK_Conditional,
11308	/// A compound assignment expression.
11309	ACK_CompAssign,
11310	};
11311
11312	// UsualArithmeticConversions - performs the UsualUnaryConversions on it's
11313	// operands and then handles various conversions that are common to binary
11314	// operators (C99 6.3.1.8). If both operands aren't arithmetic, this
11315	// routine returns the first non-arithmetic type found. The client is
11316	// responsible for emitting appropriate error diagnostics.
11317	QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
11318	SourceLocation Loc, ArithConvKind ACK);
11319
11320	/// AssignConvertType - All of the 'assignment' semantic checks return this
11321	/// enum to indicate whether the assignment was allowed. These checks are
11322	/// done for simple assignments, as well as initialization, return from
11323	/// function, argument passing, etc. The query is phrased in terms of a
11324	/// source and destination type.
11325	enum AssignConvertType {
11326	/// Compatible - the types are compatible according to the standard.
11327	Compatible,
11328
11329	/// PointerToInt - The assignment converts a pointer to an int, which we
11330	/// accept as an extension.
11331	PointerToInt,
11332
11333	/// IntToPointer - The assignment converts an int to a pointer, which we
11334	/// accept as an extension.
11335	IntToPointer,
11336
11337	/// FunctionVoidPointer - The assignment is between a function pointer and
11338	/// void, which the standard doesn't allow, but we accept as an extension.*
11339	FunctionVoidPointer,
11340
11341	/// IncompatiblePointer - The assignment is between two pointers types that
11342	/// are not compatible, but we accept them as an extension.
11343	IncompatiblePointer,
11344
11345	/// IncompatibleFunctionPointer - The assignment is between two function
11346	/// pointers types that are not compatible, but we accept them as an
11347	/// extension.
11348	IncompatibleFunctionPointer,
11349
11350	/// IncompatiblePointerSign - The assignment is between two pointers types
11351	/// which point to integers which have a different sign, but are otherwise
11352	/// identical. This is a subset of the above, but broken out because it's by
11353	/// far the most common case of incompatible pointers.
11354	IncompatiblePointerSign,
11355
11356	/// CompatiblePointerDiscardsQualifiers - The assignment discards
11357	/// c/v/r qualifiers, which we accept as an extension.
11358	CompatiblePointerDiscardsQualifiers,
11359
11360	/// IncompatiblePointerDiscardsQualifiers - The assignment
11361	/// discards qualifiers that we don't permit to be discarded,
11362	/// like address spaces.
11363	IncompatiblePointerDiscardsQualifiers,
11364
11365	/// IncompatibleNestedPointerAddressSpaceMismatch - The assignment
11366	/// changes address spaces in nested pointer types which is not allowed.
11367	/// For instance, converting __private int * to __generic int ** is*
11368	/// illegal even though __private could be converted to __generic.
11369	IncompatibleNestedPointerAddressSpaceMismatch,
11370
11371	/// IncompatibleNestedPointerQualifiers - The assignment is between two
11372	/// nested pointer types, and the qualifiers other than the first two
11373	/// levels differ e.g. char * -> const char *, but we accept them as an
11374	/// extension.
11375	IncompatibleNestedPointerQualifiers,
11376
11377	/// IncompatibleVectors - The assignment is between two vector types that
11378	/// have the same size, which we accept as an extension.
11379	IncompatibleVectors,
11380
11381	/// IntToBlockPointer - The assignment converts an int to a block
11382	/// pointer. We disallow this.
11383	IntToBlockPointer,
11384
11385	/// IncompatibleBlockPointer - The assignment is between two block
11386	/// pointers types that are not compatible.
11387	IncompatibleBlockPointer,
11388
11389	/// IncompatibleObjCQualifiedId - The assignment is between a qualified
11390	/// id type and something else (that is incompatible with it). For example,
11391	/// "id <XXX>" = "Foo ", where "Foo " doesn't implement the XXX protocol.
11392	IncompatibleObjCQualifiedId,
11393
11394	/// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an
11395	/// object with __weak qualifier.
11396	IncompatibleObjCWeakRef,
11397
11398	/// Incompatible - We reject this conversion outright, it is invalid to
11399	/// represent it in the AST.
11400	Incompatible
11401	};
11402
11403	/// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
11404	/// assignment conversion type specified by ConvTy. This returns true if the
11405	/// conversion was invalid or false if the conversion was accepted.
11406	bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
11407	SourceLocation Loc,
11408	QualType DstType, QualType SrcType,
11409	Expr *SrcExpr, AssignmentAction Action,
11410	bool Complained = nullptr*);
11411
11412	/// IsValueInFlagEnum - Determine if a value is allowed as part of a flag
11413	/// enum. If AllowMask is true, then we also allow the complement of a valid
11414	/// value, to be used as a mask.
11415	bool IsValueInFlagEnum(const EnumDecl ED, const* llvm::APInt &Val,
11416	bool AllowMask) const;
11417
11418	/// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant
11419	/// integer not in the range of enum values.
11420	void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,
11421	Expr *SrcExpr);
11422
11423	/// CheckAssignmentConstraints - Perform type checking for assignment,
11424	/// argument passing, variable initialization, and function return values.
11425	/// C99 6.5.16.
11426	AssignConvertType CheckAssignmentConstraints(SourceLocation Loc,
11427	QualType LHSType,
11428	QualType RHSType);
11429
11430	/// Check assignment constraints and optionally prepare for a conversion of
11431	/// the RHS to the LHS type. The conversion is prepared for if ConvertRHS
11432	/// is true.
11433	AssignConvertType CheckAssignmentConstraints(QualType LHSType,
11434	ExprResult &RHS,
11435	CastKind &Kind,
11436	bool ConvertRHS = true);
11437
11438	/// Check assignment constraints for an assignment of RHS to LHSType.
11439	///
11440	/// \param LHSType The destination type for the assignment.
11441	/// \param RHS The source expression for the assignment.
11442	/// \param Diagnose If \c true, diagnostics may be produced when checking
11443	/// for assignability. If a diagnostic is produced, \p RHS will be
11444	/// set to ExprError(). Note that this function may still return
11445	/// without producing a diagnostic, even for an invalid assignment.
11446	/// \param DiagnoseCFAudited If \c true, the target is a function parameter
11447	/// in an audited Core Foundation API and does not need to be checked
11448	/// for ARC retain issues.
11449	/// \param ConvertRHS If \c true, \p RHS will be updated to model the
11450	/// conversions necessary to perform the assignment. If \c false,
11451	/// \p Diagnose must also be \c false.
11452	AssignConvertType CheckSingleAssignmentConstraints(
11453	QualType LHSType, ExprResult &RHS, bool Diagnose = true,
11454	bool DiagnoseCFAudited = false, bool ConvertRHS = true);
11455
11456	// If the lhs type is a transparent union, check whether we
11457	// can initialize the transparent union with the given expression.
11458	AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType,
11459	ExprResult &RHS);
11460
11461	bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
11462
11463	bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
11464
11465	ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11466	AssignmentAction Action,
11467	bool AllowExplicit = false);
11468	ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11469	const ImplicitConversionSequence& ICS,
11470	AssignmentAction Action,
11471	CheckedConversionKind CCK
11472	= CCK_ImplicitConversion);
11473	ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11474	const StandardConversionSequence& SCS,
11475	AssignmentAction Action,
11476	CheckedConversionKind CCK);
11477
11478	ExprResult PerformQualificationConversion(
11479	Expr *E, QualType Ty, ExprValueKind VK = VK_RValue,
11480	CheckedConversionKind CCK = CCK_ImplicitConversion);
11481
11482	/// the following "Check" methods will return a valid/converted QualType
11483	/// or a null QualType (indicating an error diagnostic was issued).
11484
11485	/// type checking binary operators (subroutines of CreateBuiltinBinOp).
11486	QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS,
11487	ExprResult &RHS);
11488	QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
11489	ExprResult &RHS);
11490	QualType CheckPointerToMemberOperands( // C++ 5.5
11491	ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK,
11492	SourceLocation OpLoc, bool isIndirect);
11493	QualType CheckMultiplyDivideOperands( // C99 6.5.5
11494	ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign,
11495	bool IsDivide);
11496	QualType CheckRemainderOperands( // C99 6.5.5
11497	ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11498	bool IsCompAssign = false);
11499	QualType CheckAdditionOperands( // C99 6.5.6
11500	ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11501	BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr);
11502	QualType CheckSubtractionOperands( // C99 6.5.6
11503	ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11504	QualType* CompLHSTy = nullptr);
11505	QualType CheckShiftOperands( // C99 6.5.7
11506	ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11507	BinaryOperatorKind Opc, bool IsCompAssign = false);
11508	void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE);
11509	QualType CheckCompareOperands( // C99 6.5.8/9
11510	ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11511	BinaryOperatorKind Opc);
11512	QualType CheckBitwiseOperands( // C99 6.5.[10...12]
11513	ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11514	BinaryOperatorKind Opc);
11515	QualType CheckLogicalOperands( // C99 6.5.[13,14]
11516	ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11517	BinaryOperatorKind Opc);
11518	// CheckAssignmentOperands is used for both simple and compound assignment.
11519	// For simple assignment, pass both expressions and a null converted type.
11520	// For compound assignment, pass both expressions and the converted type.
11521	QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
11522	Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType);
11523
11524	ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc,
11525	UnaryOperatorKind Opcode, Expr *Op);
11526	ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc,
11527	BinaryOperatorKind Opcode,
11528	Expr LHS, Expr RHS);
11529	ExprResult checkPseudoObjectRValue(Expr *E);
11530	Expr recreateSyntacticForm(PseudoObjectExpr E);
11531
11532	QualType CheckConditionalOperands( // C99 6.5.15
11533	ExprResult &Cond, ExprResult &LHS, ExprResult &RHS,
11534	ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc);
11535	QualType CXXCheckConditionalOperands( // C++ 5.16
11536	ExprResult &cond, ExprResult &lhs, ExprResult &rhs,
11537	ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc);
11538	QualType CheckGNUVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS,
11539	ExprResult &RHS,
11540	SourceLocation QuestionLoc);
11541	QualType FindCompositePointerType(SourceLocation Loc, Expr &E1, Expr &E2,
11542	bool ConvertArgs = true);
11543	QualType FindCompositePointerType(SourceLocation Loc,
11544	ExprResult &E1, ExprResult &E2,
11545	bool ConvertArgs = true) {
11546	Expr E1Tmp = E1.get(), E2Tmp = E2.get();
11547	QualType Composite =
11548	FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs);
11549	E1 = E1Tmp;
11550	E2 = E2Tmp;
11551	return Composite;
11552	}
11553
11554	QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,
11555	SourceLocation QuestionLoc);
11556
11557	bool DiagnoseConditionalForNull(Expr LHSExpr, Expr RHSExpr,
11558	SourceLocation QuestionLoc);
11559
11560	void DiagnoseAlwaysNonNullPointer(Expr *E,
11561	Expr::NullPointerConstantKind NullType,
11562	bool IsEqual, SourceRange Range);
11563
11564	/// type checking for vector binary operators.
11565	QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
11566	SourceLocation Loc, bool IsCompAssign,
11567	bool AllowBothBool, bool AllowBoolConversion);
11568	QualType GetSignedVectorType(QualType V);
11569	QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
11570	SourceLocation Loc,
11571	BinaryOperatorKind Opc);
11572	QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
11573	SourceLocation Loc);
11574
11575	/// Type checking for matrix binary operators.
11576	QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS,
11577	SourceLocation Loc,
11578	bool IsCompAssign);
11579	QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS,
11580	SourceLocation Loc, bool IsCompAssign);
11581
11582	bool isValidSveBitcast(QualType srcType, QualType destType);
11583
11584	bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType);
11585	bool isLaxVectorConversion(QualType srcType, QualType destType);
11586
11587	/// type checking declaration initializers (C99 6.7.8)
11588	bool CheckForConstantInitializer(Expr *e, QualType t);
11589
11590	// type checking C++ declaration initializers (C++ [dcl.init]).
11591
11592	/// ReferenceCompareResult - Expresses the result of comparing two
11593	/// types (cv1 T1 and cv2 T2) to determine their compatibility for the
11594	/// purposes of initialization by reference (C++ [dcl.init.ref]p4).
11595	enum ReferenceCompareResult {
11596	/// Ref_Incompatible - The two types are incompatible, so direct
11597	/// reference binding is not possible.
11598	Ref_Incompatible = `0`,
11599	/// Ref_Related - The two types are reference-related, which means
11600	/// that their unqualified forms (T1 and T2) are either the same
11601	/// or T1 is a base class of T2.
11602	Ref_Related,
11603	/// Ref_Compatible - The two types are reference-compatible.
11604	Ref_Compatible
11605	};
11606
11607	// Fake up a scoped enumeration that still contextually converts to bool.
11608	struct ReferenceConversionsScope {
11609	/// The conversions that would be performed on an lvalue of type T2 when
11610	/// binding a reference of type T1 to it, as determined when evaluating
11611	/// whether T1 is reference-compatible with T2.
11612	enum ReferenceConversions {
11613	Qualification = `0x1`,
11614	NestedQualification = `0x2`,
11615	Function = `0x4`,
11616	DerivedToBase = `0x8`,
11617	ObjC = `0x10`,
11618	ObjCLifetime = `0x20`,
11619
11620	LLVM_MARK_AS_BITMASK_ENUM(/LargestValue=/ObjCLifetime)
11621	};
11622	};
11623	using ReferenceConversions = ReferenceConversionsScope::ReferenceConversions;
11624
11625	ReferenceCompareResult
11626	CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2,
11627	ReferenceConversions Conv = nullptr*);
11628
11629	ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
11630	Expr *CastExpr, CastKind &CastKind,
11631	ExprValueKind &VK, CXXCastPath &Path);
11632
11633	/// Force an expression with unknown-type to an expression of the
11634	/// given type.
11635	ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);
11636
11637	/// Type-check an expression that's being passed to an
11638	/// __unknown_anytype parameter.
11639	ExprResult checkUnknownAnyArg(SourceLocation callLoc,
11640	Expr *result, QualType &paramType);
11641
11642	// CheckVectorCast - check type constraints for vectors.
11643	// Since vectors are an extension, there are no C standard reference for this.
11644	// We allow casting between vectors and integer datatypes of the same size.
11645	// returns true if the cast is invalid
11646	bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
11647	CastKind &Kind);
11648
11649	/// Prepare `SplattedExpr` for a vector splat operation, adding
11650	/// implicit casts if necessary.
11651	ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr);
11652
11653	// CheckExtVectorCast - check type constraints for extended vectors.
11654	// Since vectors are an extension, there are no C standard reference for this.
11655	// We allow casting between vectors and integer datatypes of the same size,
11656	// or vectors and the element type of that vector.
11657	// returns the cast expr
11658	ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr,
11659	CastKind &Kind);
11660
11661	ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type,
11662	SourceLocation LParenLoc,
11663	Expr *CastExpr,
11664	SourceLocation RParenLoc);
11665
11666	enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error };
11667
11668	/// Checks for invalid conversions and casts between
11669	/// retainable pointers and other pointer kinds for ARC and Weak.
11670	ARCConversionResult CheckObjCConversion(SourceRange castRange,
11671	QualType castType, Expr *&op,
11672	CheckedConversionKind CCK,
11673	bool Diagnose = true,
11674	bool DiagnoseCFAudited = false,
11675	BinaryOperatorKind Opc = BO_PtrMemD
11676	);
11677
11678	Expr stripARCUnbridgedCast(Expr e);
11679	void diagnoseARCUnbridgedCast(Expr *e);
11680
11681	bool CheckObjCARCUnavailableWeakConversion(QualType castType,
11682	QualType ExprType);
11683
11684	/// checkRetainCycles - Check whether an Objective-C message send
11685	/// might create an obvious retain cycle.
11686	void checkRetainCycles(ObjCMessageExpr *msg);
11687	void checkRetainCycles(Expr receiver, Expr argument);
11688	void checkRetainCycles(VarDecl Var, Expr Init);
11689
11690	/// checkUnsafeAssigns - Check whether +1 expr is being assigned
11691	/// to weak/__unsafe_unretained type.
11692	bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS);
11693
11694	/// checkUnsafeExprAssigns - Check whether +1 expr is being assigned
11695	/// to weak/__unsafe_unretained expression.
11696	void checkUnsafeExprAssigns(SourceLocation Loc, Expr LHS, Expr RHS);
11697
11698	/// CheckMessageArgumentTypes - Check types in an Obj-C message send.
11699	/// \param Method - May be null.
11700	/// \param [out] ReturnType - The return type of the send.
11701	/// \return true iff there were any incompatible types.
11702	bool CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType,
11703	MultiExprArg Args, Selector Sel,
11704	ArrayRef<SourceLocation> SelectorLocs,
11705	ObjCMethodDecl Method, bool* isClassMessage,
11706	bool isSuperMessage, SourceLocation lbrac,
11707	SourceLocation rbrac, SourceRange RecRange,
11708	QualType &ReturnType, ExprValueKind &VK);
11709
11710	/// Determine the result of a message send expression based on
11711	/// the type of the receiver, the method expected to receive the message,
11712	/// and the form of the message send.
11713	QualType getMessageSendResultType(const Expr *Receiver, QualType ReceiverType,
11714	ObjCMethodDecl Method, bool* isClassMessage,
11715	bool isSuperMessage);
11716
11717	/// If the given expression involves a message send to a method
11718	/// with a related result type, emit a note describing what happened.
11719	void EmitRelatedResultTypeNote(const Expr *E);
11720
11721	/// Given that we had incompatible pointer types in a return
11722	/// statement, check whether we're in a method with a related result
11723	/// type, and if so, emit a note describing what happened.
11724	void EmitRelatedResultTypeNoteForReturn(QualType destType);
11725
11726	class ConditionResult {
11727	Decl *ConditionVar;
11728	FullExprArg Condition;
11729	bool Invalid;
11730	bool HasKnownValue;
11731	bool KnownValue;
11732
11733	friend class Sema;
11734	ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition,
11735	bool IsConstexpr)
11736	: ConditionVar(ConditionVar), Condition (Condition), Invalid(false),
11737	HasKnownValue(IsConstexpr && Condition.get() &&
11738	!Condition.get()->isValueDependent()),
11739	KnownValue(HasKnownValue &&
11740	!!Condition.get()->EvaluateKnownConstInt(S.Context)) {}
11741	explicit ConditionResult(bool Invalid)
11742	: ConditionVar(nullptr), Condition (nullptr), Invalid(Invalid),
11743	HasKnownValue(false), KnownValue(false) {}
11744
11745	public:
11746	ConditionResult() : ConditionResult (false) {}
11747	bool isInvalid() const { return Invalid; }
11748	std::pair<VarDecl , Expr > get() const {
11749	return std::make_pair(cast_or_null<VarDecl>(ConditionVar),
11750	Condition.get());
11751	}
11752	llvm::Optional<bool> getKnownValue() const {
11753	if (!HasKnownValue)
11754	return None;
11755	return KnownValue;
11756	}
11757	};
11758	static ConditionResult ConditionError() { return ConditionResult (true); }
11759
11760	enum class ConditionKind {
11761	Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'.
11762	ConstexprIf, ///< A constant boolean condition from 'if constexpr'.
11763	Switch ///< An integral condition for a 'switch' statement.
11764	};
11765
11766	ConditionResult ActOnCondition(Scope *S, SourceLocation Loc,
11767	Expr *SubExpr, ConditionKind CK);
11768
11769	ConditionResult ActOnConditionVariable(Decl *ConditionVar,
11770	SourceLocation StmtLoc,
11771	ConditionKind CK);
11772
11773	DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D);
11774
11775	ExprResult CheckConditionVariable(VarDecl *ConditionVar,
11776	SourceLocation StmtLoc,
11777	ConditionKind CK);
11778	ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond);
11779
11780	/// CheckBooleanCondition - Diagnose problems involving the use of
11781	/// the given expression as a boolean condition (e.g. in an if
11782	/// statement). Also performs the standard function and array
11783	/// decays, possibly changing the input variable.
11784	///
11785	/// \param Loc - A location associated with the condition, e.g. the
11786	/// 'if' keyword.
11787	/// \return true iff there were any errors
11788	ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,
11789	bool IsConstexpr = false);
11790
11791	/// ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression
11792	/// found in an explicit(bool) specifier.
11793	ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E);
11794
11795	/// tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
11796	/// Returns true if the explicit specifier is now resolved.
11797	bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec);
11798
11799	/// DiagnoseAssignmentAsCondition - Given that an expression is
11800	/// being used as a boolean condition, warn if it's an assignment.
11801	void DiagnoseAssignmentAsCondition(Expr *E);
11802
11803	/// Redundant parentheses over an equality comparison can indicate
11804	/// that the user intended an assignment used as condition.
11805	void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
11806
11807	/// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
11808	ExprResult CheckCXXBooleanCondition(Expr CondExpr, bool* IsConstexpr = false);
11809
11810	/// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
11811	/// the specified width and sign. If an overflow occurs, detect it and emit
11812	/// the specified diagnostic.
11813	void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
11814	unsigned NewWidth, bool NewSign,
11815	SourceLocation Loc, unsigned DiagID);
11816
11817	/// Checks that the Objective-C declaration is declared in the global scope.
11818	/// Emits an error and marks the declaration as invalid if it's not declared
11819	/// in the global scope.
11820	bool CheckObjCDeclScope(Decl *D);
11821
11822	/// Abstract base class used for diagnosing integer constant
11823	/// expression violations.
11824	class VerifyICEDiagnoser {
11825	public:
11826	bool Suppress;
11827
11828	VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { }
11829
11830	virtual SemaDiagnosticBuilder
11831	diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T);
11832	virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
11833	SourceLocation Loc) = `0`;
11834	virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc);
11835	virtual ~VerifyICEDiagnoser() {}
11836	};
11837
11838	enum AllowFoldKind {
11839	NoFold,
11840	AllowFold,
11841	};
11842
11843	/// VerifyIntegerConstantExpression - Verifies that an expression is an ICE,
11844	/// and reports the appropriate diagnostics. Returns false on success.
11845	/// Can optionally return the value of the expression.
11846	ExprResult VerifyIntegerConstantExpression(Expr E, llvm::APSInt Result,
11847	VerifyICEDiagnoser &Diagnoser,
11848	AllowFoldKind CanFold = NoFold);
11849	ExprResult VerifyIntegerConstantExpression(Expr E, llvm::APSInt Result,
11850	unsigned DiagID,
11851	AllowFoldKind CanFold = NoFold);
11852	ExprResult VerifyIntegerConstantExpression(Expr *E,
11853	llvm::APSInt Result = nullptr*,
11854	AllowFoldKind CanFold = NoFold);
11855	ExprResult VerifyIntegerConstantExpression(Expr *E,
11856	AllowFoldKind CanFold = NoFold) {
11857	return VerifyIntegerConstantExpression(E, nullptr, CanFold);
11858	}
11859
11860	/// VerifyBitField - verifies that a bit field expression is an ICE and has
11861	/// the correct width, and that the field type is valid.
11862	/// Returns false on success.
11863	/// Can optionally return whether the bit-field is of width 0
11864	ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
11865	QualType FieldTy, bool IsMsStruct,
11866	Expr BitWidth, bool* ZeroWidth = nullptr*);
11867
11868	private:
11869	unsigned ForceCUDAHostDeviceDepth = `0`;
11870
11871	public:
11872	/// Increments our count of the number of times we've seen a pragma forcing
11873	/// functions to be __host__ __device__. So long as this count is greater
11874	/// than zero, all functions encountered will be __host__ __device__.
11875	void PushForceCUDAHostDevice();
11876
11877	/// Decrements our count of the number of times we've seen a pragma forcing
11878	/// functions to be __host__ __device__. Returns false if the count is 0
11879	/// before incrementing, so you can emit an error.
11880	bool PopForceCUDAHostDevice();
11881
11882	/// Diagnostics that are emitted only if we discover that the given function
11883	/// must be codegen'ed. Because handling these correctly adds overhead to
11884	/// compilation, this is currently only enabled for CUDA compilations.
11885	llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>,
11886	std::vector<PartialDiagnosticAt>>
11887	DeviceDeferredDiags;
11888
11889	/// A pair of a canonical FunctionDecl and a SourceLocation. When used as the
11890	/// key in a hashtable, both the FD and location are hashed.
11891	struct FunctionDeclAndLoc {
11892	CanonicalDeclPtr<FunctionDecl> FD;
11893	SourceLocation Loc;
11894	};
11895
11896	/// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a
11897	/// (maybe deferred) "bad call" diagnostic. We use this to avoid emitting the
11898	/// same deferred diag twice.
11899	llvm::DenseSet<FunctionDeclAndLoc> LocsWithCUDACallDiags;
11900
11901	/// An inverse call graph, mapping known-emitted functions to one of their
11902	/// known-emitted callers (plus the location of the call).
11903	///
11904	/// Functions that we can tell a priori must be emitted aren't added to this
11905	/// map.
11906	llvm::DenseMap</ Callee = / CanonicalDeclPtr<FunctionDecl>,
11907	/ Caller = / FunctionDeclAndLoc>
11908	DeviceKnownEmittedFns;
11909
11910	/// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
11911	/// context is "used as device code".
11912	///
11913	/// - If CurContext is a __host__ function, does not emit any diagnostics
11914	/// unless \p EmitOnBothSides is true.
11915	/// - If CurContext is a __device__ or __global__ function, emits the
11916	/// diagnostics immediately.
11917	/// - If CurContext is a __host__ __device__ function and we are compiling for
11918	/// the device, creates a diagnostic which is emitted if and when we realize
11919	/// that the function will be codegen'ed.
11920	///
11921	/// Example usage:
11922	///
11923	/// // Variable-length arrays are not allowed in CUDA device code.
11924	/// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget())
11925	/// return ExprError();
11926	/// // Otherwise, continue parsing as normal.
11927	SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc,
11928	unsigned DiagID);
11929
11930	/// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
11931	/// context is "used as host code".
11932	///
11933	/// Same as CUDADiagIfDeviceCode, with "host" and "device" switched.
11934	SemaDiagnosticBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID);
11935
11936	/// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
11937	/// context is "used as device code".
11938	///
11939	/// - If CurContext is a `declare target` function or it is known that the
11940	/// function is emitted for the device, emits the diagnostics immediately.
11941	/// - If CurContext is a non-`declare target` function and we are compiling
11942	/// for the device, creates a diagnostic which is emitted if and when we
11943	/// realize that the function will be codegen'ed.
11944	///
11945	/// Example usage:
11946	///
11947	/// // Variable-length arrays are not allowed in NVPTX device code.
11948	/// if (diagIfOpenMPDeviceCode(Loc, diag::err_vla_unsupported))
11949	/// return ExprError();
11950	/// // Otherwise, continue parsing as normal.
11951	SemaDiagnosticBuilder
11952	diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD);
11953
11954	/// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
11955	/// context is "used as host code".
11956	///
11957	/// - If CurContext is a `declare target` function or it is known that the
11958	/// function is emitted for the host, emits the diagnostics immediately.
11959	/// - If CurContext is a non-host function, just ignore it.
11960	///
11961	/// Example usage:
11962	///
11963	/// // Variable-length arrays are not allowed in NVPTX device code.
11964	/// if (diagIfOpenMPHostode(Loc, diag::err_vla_unsupported))
11965	/// return ExprError();
11966	/// // Otherwise, continue parsing as normal.
11967	SemaDiagnosticBuilder diagIfOpenMPHostCode(SourceLocation Loc,
11968	unsigned DiagID, FunctionDecl *FD);
11969
11970	SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID,
11971	FunctionDecl FD = nullptr*);
11972	SemaDiagnosticBuilder targetDiag(SourceLocation Loc,
11973	const PartialDiagnostic &PD,
11974	FunctionDecl FD = nullptr*) {
11975	return targetDiag(Loc, PD.getDiagID(), FD) << PD;
11976	}
11977
11978	/// Check if the expression is allowed to be used in expressions for the
11979	/// offloading devices.
11980	void checkDeviceDecl(ValueDecl *D, SourceLocation Loc);
11981
11982	enum CUDAFunctionTarget {
11983	CFT_Device,
11984	CFT_Global,
11985	CFT_Host,
11986	CFT_HostDevice,
11987	CFT_InvalidTarget
11988	};
11989
11990	/// Determines whether the given function is a CUDA device/host/kernel/etc.
11991	/// function.
11992	///
11993	/// Use this rather than examining the function's attributes yourself -- you
11994	/// will get it wrong. Returns CFT_Host if D is null.
11995	CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D,
11996	bool IgnoreImplicitHDAttr = false);
11997	CUDAFunctionTarget IdentifyCUDATarget(const ParsedAttributesView &Attrs);
11998
11999	/// Gets the CUDA target for the current context.
12000	CUDAFunctionTarget CurrentCUDATarget() {
12001	return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext));
12002	}
12003
12004	static bool isCUDAImplicitHostDeviceFunction(const FunctionDecl *D);
12005
12006	// CUDA function call preference. Must be ordered numerically from
12007	// worst to best.
12008	enum CUDAFunctionPreference {
12009	CFP_Never, // Invalid caller/callee combination.
12010	CFP_WrongSide, // Calls from host-device to host or device
12011	// function that do not match current compilation
12012	// mode.
12013	CFP_HostDevice, // Any calls to host/device functions.
12014	CFP_SameSide, // Calls from host-device to host or device
12015	// function matching current compilation mode.
12016	CFP_Native, // host-to-host or device-to-device calls.
12017	};
12018
12019	/// Identifies relative preference of a given Caller/Callee
12020	/// combination, based on their host/device attributes.
12021	/// \param Caller function which needs address of \p Callee.
12022	/// nullptr in case of global context.
12023	/// \param Callee target function
12024	///
12025	/// \returns preference value for particular Caller/Callee combination.
12026	CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller,
12027	const FunctionDecl *Callee);
12028
12029	/// Determines whether Caller may invoke Callee, based on their CUDA
12030	/// host/device attributes. Returns false if the call is not allowed.
12031	///
12032	/// Note: Will return true for CFP_WrongSide calls. These may appear in
12033	/// semantically correct CUDA programs, but only if they're never codegen'ed.
12034	bool IsAllowedCUDACall(const FunctionDecl *Caller,
12035	const FunctionDecl *Callee) {
12036	return IdentifyCUDAPreference(Caller, Callee) != CFP_Never;
12037	}
12038
12039	/// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD,
12040	/// depending on FD and the current compilation settings.
12041	void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD,
12042	const LookupResult &Previous);
12043
12044	/// May add implicit CUDAConstantAttr attribute to VD, depending on VD
12045	/// and current compilation settings.
12046	void MaybeAddCUDAConstantAttr(VarDecl *VD);
12047
12048	public:
12049	/// Check whether we're allowed to call Callee from the current context.
12050	///
12051	/// - If the call is never allowed in a semantically-correct program
12052	/// (CFP_Never), emits an error and returns false.
12053	///
12054	/// - If the call is allowed in semantically-correct programs, but only if
12055	/// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to
12056	/// be emitted if and when the caller is codegen'ed, and returns true.
12057	///
12058	/// Will only create deferred diagnostics for a given SourceLocation once,
12059	/// so you can safely call this multiple times without generating duplicate
12060	/// deferred errors.
12061	///
12062	/// - Otherwise, returns true without emitting any diagnostics.
12063	bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee);
12064
12065	void CUDACheckLambdaCapture(CXXMethodDecl D, const* sema::Capture &Capture);
12066
12067	/// Set __device__ or __host__ __device__ attributes on the given lambda
12068	/// operator() method.
12069	///
12070	/// CUDA lambdas by default is host device function unless it has explicit
12071	/// host or device attribute.
12072	void CUDASetLambdaAttrs(CXXMethodDecl *Method);
12073
12074	/// Finds a function in \p Matches with highest calling priority
12075	/// from \p Caller context and erases all functions with lower
12076	/// calling priority.
12077	void EraseUnwantedCUDAMatches(
12078	const FunctionDecl *Caller,
12079	SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches);
12080
12081	/// Given a implicit special member, infer its CUDA target from the
12082	/// calls it needs to make to underlying base/field special members.
12083	/// \param ClassDecl the class for which the member is being created.
12084	/// \param CSM the kind of special member.
12085	/// \param MemberDecl the special member itself.
12086	/// \param ConstRHS true if this is a copy operation with a const object on
12087	/// its RHS.
12088	/// \param Diagnose true if this call should emit diagnostics.
12089	/// \return true if there was an error inferring.
12090	/// The result of this call is implicit CUDA target attribute(s) attached to
12091	/// the member declaration.
12092	bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,
12093	CXXSpecialMember CSM,
12094	CXXMethodDecl *MemberDecl,
12095	bool ConstRHS,
12096	bool Diagnose);
12097
12098	/// \return true if \p CD can be considered empty according to CUDA
12099	/// (E.2.3.1 in CUDA 7.5 Programming guide).
12100	bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD);
12101	bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD);
12102
12103	// \brief Checks that initializers of \p Var satisfy CUDA restrictions. In
12104	// case of error emits appropriate diagnostic and invalidates \p Var.
12105	//
12106	// \details CUDA allows only empty constructors as initializers for global
12107	// variables (see E.2.3.1, CUDA 7.5). The same restriction also applies to all
12108	// __shared__ variables whether they are local or not (they all are implicitly
12109	// static in CUDA). One exception is that CUDA allows constant initializers
12110	// for __constant__ and __device__ variables.
12111	void checkAllowedCUDAInitializer(VarDecl *VD);
12112
12113	/// Check whether NewFD is a valid overload for CUDA. Emits
12114	/// diagnostics and invalidates NewFD if not.
12115	void checkCUDATargetOverload(FunctionDecl *NewFD,
12116	const LookupResult &Previous);
12117	/// Copies target attributes from the template TD to the function FD.
12118	void inheritCUDATargetAttrs(FunctionDecl FD, const* FunctionTemplateDecl &TD);
12119
12120	/// Returns the name of the launch configuration function. This is the name
12121	/// of the function that will be called to configure kernel call, with the
12122	/// parameters specified via <<<>>>.
12123	std::string getCudaConfigureFuncName() const;
12124
12125	/// \name Code completion
12126	//@{
12127	/// Describes the context in which code completion occurs.
12128	enum ParserCompletionContext {
12129	/// Code completion occurs at top-level or namespace context.
12130	PCC_Namespace,
12131	/// Code completion occurs within a class, struct, or union.
12132	PCC_Class,
12133	/// Code completion occurs within an Objective-C interface, protocol,
12134	/// or category.
12135	PCC_ObjCInterface,
12136	/// Code completion occurs within an Objective-C implementation or
12137	/// category implementation
12138	PCC_ObjCImplementation,
12139	/// Code completion occurs within the list of instance variables
12140	/// in an Objective-C interface, protocol, category, or implementation.
12141	PCC_ObjCInstanceVariableList,
12142	/// Code completion occurs following one or more template
12143	/// headers.
12144	PCC_Template,
12145	/// Code completion occurs following one or more template
12146	/// headers within a class.
12147	PCC_MemberTemplate,
12148	/// Code completion occurs within an expression.
12149	PCC_Expression,
12150	/// Code completion occurs within a statement, which may
12151	/// also be an expression or a declaration.
12152	PCC_Statement,
12153	/// Code completion occurs at the beginning of the
12154	/// initialization statement (or expression) in a for loop.
12155	PCC_ForInit,
12156	/// Code completion occurs within the condition of an if,
12157	/// while, switch, or for statement.
12158	PCC_Condition,
12159	/// Code completion occurs within the body of a function on a
12160	/// recovery path, where we do not have a specific handle on our position
12161	/// in the grammar.
12162	PCC_RecoveryInFunction,
12163	/// Code completion occurs where only a type is permitted.
12164	PCC_Type,
12165	/// Code completion occurs in a parenthesized expression, which
12166	/// might also be a type cast.
12167	PCC_ParenthesizedExpression,
12168	/// Code completion occurs within a sequence of declaration
12169	/// specifiers within a function, method, or block.
12170	PCC_LocalDeclarationSpecifiers
12171	};
12172
12173	void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path);
12174	void CodeCompleteOrdinaryName(Scope *S,
12175	ParserCompletionContext CompletionContext);
12176	void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
12177	bool AllowNonIdentifiers,
12178	bool AllowNestedNameSpecifiers);
12179
12180	struct CodeCompleteExpressionData;
12181	void CodeCompleteExpression(Scope *S,
12182	const CodeCompleteExpressionData &Data);
12183	void CodeCompleteExpression(Scope *S, QualType PreferredType,
12184	bool IsParenthesized = false);
12185	void CodeCompleteMemberReferenceExpr(Scope S, Expr Base, Expr *OtherOpBase,
12186	SourceLocation OpLoc, bool IsArrow,
12187	bool IsBaseExprStatement,
12188	QualType PreferredType);
12189	void CodeCompletePostfixExpression(Scope *S, ExprResult LHS,
12190	QualType PreferredType);
12191	void CodeCompleteTag(Scope S, unsigned* TagSpec);
12192	void CodeCompleteTypeQualifiers(DeclSpec &DS);
12193	void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
12194	const VirtSpecifiers VS = nullptr*);
12195	void CodeCompleteBracketDeclarator(Scope *S);
12196	void CodeCompleteCase(Scope *S);
12197	/// Reports signatures for a call to CodeCompleteConsumer and returns the
12198	/// preferred type for the current argument. Returned type can be null.
12199	QualType ProduceCallSignatureHelp(Scope S, Expr Fn, ArrayRef<Expr *> Args,
12200	SourceLocation OpenParLoc);
12201	QualType ProduceConstructorSignatureHelp(Scope *S, QualType Type,
12202	SourceLocation Loc,
12203	ArrayRef<Expr *> Args,
12204	SourceLocation OpenParLoc);
12205	QualType ProduceCtorInitMemberSignatureHelp(Scope S, Decl ConstructorDecl,
12206	CXXScopeSpec SS,
12207	ParsedType TemplateTypeTy,
12208	ArrayRef<Expr *> ArgExprs,
12209	IdentifierInfo *II,
12210	SourceLocation OpenParLoc);
12211	void CodeCompleteInitializer(Scope S, Decl D);
12212	/// Trigger code completion for a record of \p BaseType. \p InitExprs are
12213	/// expressions in the initializer list seen so far and \p D is the current
12214	/// Designation being parsed.
12215	void CodeCompleteDesignator(const QualType BaseType,
12216	llvm::ArrayRef<Expr *> InitExprs,
12217	const Designation &D);
12218	void CodeCompleteAfterIf(Scope S, bool* IsBracedThen);
12219
12220	void CodeCompleteQualifiedId(Scope S, CXXScopeSpec &SS, bool* EnteringContext,
12221	bool IsUsingDeclaration, QualType BaseType,
12222	QualType PreferredType);
12223	void CodeCompleteUsing(Scope *S);
12224	void CodeCompleteUsingDirective(Scope *S);
12225	void CodeCompleteNamespaceDecl(Scope *S);
12226	void CodeCompleteNamespaceAliasDecl(Scope *S);
12227	void CodeCompleteOperatorName(Scope *S);
12228	void CodeCompleteConstructorInitializer(
12229	Decl *Constructor,
12230	ArrayRef<CXXCtorInitializer *> Initializers);
12231
12232	void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
12233	bool AfterAmpersand);
12234	void CodeCompleteAfterFunctionEquals(Declarator &D);
12235
12236	void CodeCompleteObjCAtDirective(Scope *S);
12237	void CodeCompleteObjCAtVisibility(Scope *S);
12238	void CodeCompleteObjCAtStatement(Scope *S);
12239	void CodeCompleteObjCAtExpression(Scope *S);
12240	void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);
12241	void CodeCompleteObjCPropertyGetter(Scope *S);
12242	void CodeCompleteObjCPropertySetter(Scope *S);
12243	void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
12244	bool IsParameter);
12245	void CodeCompleteObjCMessageReceiver(Scope *S);
12246	void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
12247	ArrayRef<IdentifierInfo *> SelIdents,
12248	bool AtArgumentExpression);
12249	void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
12250	ArrayRef<IdentifierInfo *> SelIdents,
12251	bool AtArgumentExpression,
12252	bool IsSuper = false);
12253	void CodeCompleteObjCInstanceMessage(Scope S, Expr Receiver,
12254	ArrayRef<IdentifierInfo *> SelIdents,
12255	bool AtArgumentExpression,
12256	ObjCInterfaceDecl Super = nullptr*);
12257	void CodeCompleteObjCForCollection(Scope *S,
12258	DeclGroupPtrTy IterationVar);
12259	void CodeCompleteObjCSelector(Scope *S,
12260	ArrayRef<IdentifierInfo *> SelIdents);
12261	void CodeCompleteObjCProtocolReferences(
12262	ArrayRef<IdentifierLocPair> Protocols);
12263	void CodeCompleteObjCProtocolDecl(Scope *S);
12264	void CodeCompleteObjCInterfaceDecl(Scope *S);
12265	void CodeCompleteObjCSuperclass(Scope *S,
12266	IdentifierInfo *ClassName,
12267	SourceLocation ClassNameLoc);
12268	void CodeCompleteObjCImplementationDecl(Scope *S);
12269	void CodeCompleteObjCInterfaceCategory(Scope *S,
12270	IdentifierInfo *ClassName,
12271	SourceLocation ClassNameLoc);
12272	void CodeCompleteObjCImplementationCategory(Scope *S,
12273	IdentifierInfo *ClassName,
12274	SourceLocation ClassNameLoc);
12275	void CodeCompleteObjCPropertyDefinition(Scope *S);
12276	void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
12277	IdentifierInfo *PropertyName);
12278	void CodeCompleteObjCMethodDecl(Scope S, Optional<bool*> IsInstanceMethod,
12279	ParsedType ReturnType);
12280	void CodeCompleteObjCMethodDeclSelector(Scope *S,
12281	bool IsInstanceMethod,
12282	bool AtParameterName,
12283	ParsedType ReturnType,
12284	ArrayRef<IdentifierInfo *> SelIdents);
12285	void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName,
12286	SourceLocation ClassNameLoc,
12287	bool IsBaseExprStatement);
12288	void CodeCompletePreprocessorDirective(bool InConditional);
12289	void CodeCompleteInPreprocessorConditionalExclusion(Scope *S);
12290	void CodeCompletePreprocessorMacroName(bool IsDefinition);
12291	void CodeCompletePreprocessorExpression();
12292	void CodeCompletePreprocessorMacroArgument(Scope *S,
12293	IdentifierInfo *Macro,
12294	MacroInfo *MacroInfo,
12295	unsigned Argument);
12296	void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled);
12297	void CodeCompleteNaturalLanguage();
12298	void CodeCompleteAvailabilityPlatformName();
12299	void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
12300	CodeCompletionTUInfo &CCTUInfo,
12301	SmallVectorImpl<CodeCompletionResult> &Results);
12302	//@}
12303
12304	//===--------------------------------------------------------------------===//
12305	// Extra semantic analysis beyond the C type system
12306
12307	public:
12308	SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
12309	unsigned ByteNo) const;
12310
12311	private:
12312	void CheckArrayAccess(const Expr BaseExpr, const* Expr *IndexExpr,
12313	const ArraySubscriptExpr ASE=nullptr*,
12314	bool AllowOnePastEnd=true, bool IndexNegated=false);
12315	void CheckArrayAccess(const Expr *E);
12316	// Used to grab the relevant information from a FormatAttr and a
12317	// FunctionDeclaration.
12318	struct FormatStringInfo {
12319	unsigned FormatIdx;
12320	unsigned FirstDataArg;
12321	bool HasVAListArg;
12322	};
12323
12324	static bool getFormatStringInfo(const FormatAttr Format, bool* IsCXXMember,
12325	FormatStringInfo *FSI);
12326	bool CheckFunctionCall(FunctionDecl FDecl, CallExpr TheCall,
12327	const FunctionProtoType *Proto);
12328	bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc,
12329	ArrayRef<const Expr *> Args);
12330	bool CheckPointerCall(NamedDecl NDecl, CallExpr TheCall,
12331	const FunctionProtoType *Proto);
12332	bool CheckOtherCall(CallExpr TheCall, const* FunctionProtoType *Proto);
12333	void CheckConstructorCall(FunctionDecl *FDecl,
12334	ArrayRef<const Expr *> Args,
12335	const FunctionProtoType *Proto,
12336	SourceLocation Loc);
12337
12338	void checkCall(NamedDecl FDecl, const* FunctionProtoType *Proto,
12339	const Expr ThisArg, ArrayRef<const* Expr *> Args,
12340	bool IsMemberFunction, SourceLocation Loc, SourceRange Range,
12341	VariadicCallType CallType);
12342
12343	bool CheckObjCString(Expr *Arg);
12344	ExprResult CheckOSLogFormatStringArg(Expr *Arg);
12345
12346	ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl,
12347	unsigned BuiltinID, CallExpr *TheCall);
12348
12349	bool CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12350	CallExpr *TheCall);
12351
12352	void checkFortifiedBuiltinMemoryFunction(FunctionDecl FD, CallExpr TheCall);
12353
12354	bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
12355	unsigned MaxWidth);
12356	bool CheckNeonBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12357	CallExpr *TheCall);
12358	bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12359	bool CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12360	bool CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12361	CallExpr *TheCall);
12362	bool CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg,
12363	bool WantCDE);
12364	bool CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12365	CallExpr *TheCall);
12366
12367	bool CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12368	CallExpr *TheCall);
12369	bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12370	bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12371	bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
12372	bool CheckMipsBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12373	CallExpr *TheCall);
12374	bool CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID,
12375	CallExpr *TheCall);
12376	bool CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
12377	bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12378	bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall);
12379	bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall);
12380	bool CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall);
12381	bool CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall,
12382	ArrayRef<int> ArgNums);
12383	bool CheckX86BuiltinTileDuplicate(CallExpr TheCall, ArrayRef<int*> ArgNums);
12384	bool CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall,
12385	ArrayRef<int> ArgNums);
12386	bool CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12387	CallExpr *TheCall);
12388	bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12389	CallExpr *TheCall);
12390	bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12391
12392	bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
12393	bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
12394	bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
12395	bool SemaBuiltinFPClassification(CallExpr TheCall, unsigned* NumArgs);
12396	bool SemaBuiltinComplex(CallExpr *TheCall);
12397	bool SemaBuiltinVSX(CallExpr *TheCall);
12398	bool SemaBuiltinOSLogFormat(CallExpr *TheCall);
12399
12400	public:
12401	// Used by C++ template instantiation.
12402	ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
12403	ExprResult SemaConvertVectorExpr(Expr E, TypeSourceInfo TInfo,
12404	SourceLocation BuiltinLoc,
12405	SourceLocation RParenLoc);
12406
12407	private:
12408	bool SemaBuiltinPrefetch(CallExpr *TheCall);
12409	bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall);
12410	bool SemaBuiltinAssume(CallExpr *TheCall);
12411	bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
12412	bool SemaBuiltinLongjmp(CallExpr *TheCall);
12413	bool SemaBuiltinSetjmp(CallExpr *TheCall);
12414	ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
12415	ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult);
12416	ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,
12417	AtomicExpr::AtomicOp Op);
12418	ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult,
12419	bool IsDelete);
12420	bool SemaBuiltinConstantArg(CallExpr TheCall, int* ArgNum,
12421	llvm::APSInt &Result);
12422	bool SemaBuiltinConstantArgRange(CallExpr TheCall, int* ArgNum, int Low,
12423	int High, bool RangeIsError = true);
12424	bool SemaBuiltinConstantArgMultiple(CallExpr TheCall, int* ArgNum,
12425	unsigned Multiple);
12426	bool SemaBuiltinConstantArgPower2(CallExpr TheCall, int* ArgNum);
12427	bool SemaBuiltinConstantArgShiftedByte(CallExpr TheCall, int* ArgNum,
12428	unsigned ArgBits);
12429	bool SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr TheCall, int* ArgNum,
12430	unsigned ArgBits);
12431	bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
12432	int ArgNum, unsigned ExpectedFieldNum,
12433	bool AllowName);
12434	bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall);
12435	bool SemaBuiltinPPCMMACall(CallExpr TheCall, const* char *TypeDesc);
12436
12437	bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc);
12438
12439	// Matrix builtin handling.
12440	ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall,
12441	ExprResult CallResult);
12442	ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
12443	ExprResult CallResult);
12444	ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
12445	ExprResult CallResult);
12446
12447	public:
12448	enum FormatStringType {
12449	FST_Scanf,
12450	FST_Printf,
12451	FST_NSString,
12452	FST_Strftime,
12453	FST_Strfmon,
12454	FST_Kprintf,
12455	FST_FreeBSDKPrintf,
12456	FST_OSTrace,
12457	FST_OSLog,
12458	FST_Unknown
12459	};
12460	static FormatStringType GetFormatStringType(const FormatAttr *Format);
12461
12462	bool FormatStringHasSArg(const StringLiteral *FExpr);
12463
12464	static bool GetFormatNSStringIdx(const FormatAttr Format, unsigned* &Idx);
12465
12466	private:
12467	bool CheckFormatArguments(const FormatAttr *Format,
12468	ArrayRef<const Expr *> Args,
12469	bool IsCXXMember,
12470	VariadicCallType CallType,
12471	SourceLocation Loc, SourceRange Range,
12472	llvm::SmallBitVector &CheckedVarArgs);
12473	bool CheckFormatArguments(ArrayRef<const Expr *> Args,
12474	bool HasVAListArg, unsigned format_idx,
12475	unsigned firstDataArg, FormatStringType Type,
12476	VariadicCallType CallType,
12477	SourceLocation Loc, SourceRange range,
12478	llvm::SmallBitVector &CheckedVarArgs);
12479
12480	void CheckAbsoluteValueFunction(const CallExpr *Call,
12481	const FunctionDecl *FDecl);
12482
12483	void CheckMaxUnsignedZero(const CallExpr Call, const* FunctionDecl *FDecl);
12484
12485	void CheckMemaccessArguments(const CallExpr *Call,
12486	unsigned BId,
12487	IdentifierInfo *FnName);
12488
12489	void CheckStrlcpycatArguments(const CallExpr *Call,
12490	IdentifierInfo *FnName);
12491
12492	void CheckStrncatArguments(const CallExpr *Call,
12493	IdentifierInfo *FnName);
12494
12495	void CheckFreeArguments(const CallExpr *E);
12496
12497	void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
12498	SourceLocation ReturnLoc,
12499	bool isObjCMethod = false,
12500	const AttrVec Attrs = nullptr*,
12501	const FunctionDecl FD = nullptr*);
12502
12503	public:
12504	void CheckFloatComparison(SourceLocation Loc, Expr LHS, Expr RHS);
12505
12506	private:
12507	void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation ());
12508	void CheckBoolLikeConversion(Expr *E, SourceLocation CC);
12509	void CheckForIntOverflow(Expr *E);
12510	void CheckUnsequencedOperations(const Expr *E);
12511
12512	/// Perform semantic checks on a completed expression. This will either
12513	/// be a full-expression or a default argument expression.
12514	void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation (),
12515	bool IsConstexpr = false);
12516
12517	void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field,
12518	Expr *Init);
12519
12520	/// Check if there is a field shadowing.
12521	void CheckShadowInheritedFields(const SourceLocation &Loc,
12522	DeclarationName FieldName,
12523	const CXXRecordDecl *RD,
12524	bool DeclIsField = true);
12525
12526	/// Check if the given expression contains 'break' or 'continue'
12527	/// statement that produces control flow different from GCC.
12528	void CheckBreakContinueBinding(Expr *E);
12529
12530	/// Check whether receiver is mutable ObjC container which
12531	/// attempts to add itself into the container
12532	void CheckObjCCircularContainer(ObjCMessageExpr *Message);
12533
12534	void CheckTCBEnforcement(const CallExpr TheCall, const* FunctionDecl *Callee);
12535
12536	void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE);
12537	void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
12538	bool DeleteWasArrayForm);
12539	public:
12540	/// Register a magic integral constant to be used as a type tag.
12541	void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
12542	uint64_t MagicValue, QualType Type,
12543	bool LayoutCompatible, bool MustBeNull);
12544
12545	struct TypeTagData {
12546	TypeTagData() {}
12547
12548	TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) :
12549	Type (Type), LayoutCompatible(LayoutCompatible),
12550	MustBeNull(MustBeNull)
12551	{}
12552
12553	QualType Type;
12554
12555	/// If true, \c Type should be compared with other expression's types for
12556	/// layout-compatibility.
12557	unsigned LayoutCompatible : `1`;
12558	unsigned MustBeNull : `1`;
12559	};
12560
12561	/// A pair of ArgumentKind identifier and magic value. This uniquely
12562	/// identifies the magic value.
12563	typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue;
12564
12565	private:
12566	/// A map from magic value to type information.
12567	std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>
12568	TypeTagForDatatypeMagicValues;
12569
12570	/// Peform checks on a call of a function with argument_with_type_tag
12571	/// or pointer_with_type_tag attributes.
12572	void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr,
12573	const ArrayRef<const Expr *> ExprArgs,
12574	SourceLocation CallSiteLoc);
12575
12576	/// Check if we are taking the address of a packed field
12577	/// as this may be a problem if the pointer value is dereferenced.
12578	void CheckAddressOfPackedMember(Expr *rhs);
12579
12580	/// The parser's current scope.
12581	///
12582	/// The parser maintains this state here.
12583	Scope *CurScope;
12584
12585	mutable IdentifierInfo *Ident_super;
12586	mutable IdentifierInfo *Ident___float128;
12587
12588	/// Nullability type specifiers.
12589	IdentifierInfo Ident__Nonnull = nullptr*;
12590	IdentifierInfo Ident__Nullable = nullptr*;
12591	IdentifierInfo Ident__Nullable_result = nullptr*;
12592	IdentifierInfo Ident__Null_unspecified = nullptr*;
12593
12594	IdentifierInfo Ident_NSError = nullptr*;
12595
12596	/// The handler for the FileChanged preprocessor events.
12597	///
12598	/// Used for diagnostics that implement custom semantic analysis for #include
12599	/// directives, like -Wpragma-pack.
12600	sema::SemaPPCallbacks *SemaPPCallbackHandler;
12601
12602	protected:
12603	friend class Parser;
12604	friend class InitializationSequence;
12605	friend class ASTReader;
12606	friend class ASTDeclReader;
12607	friend class ASTWriter;
12608
12609	public:
12610	/// Retrieve the keyword associated
12611	IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability);
12612
12613	/// The struct behind the CFErrorRef pointer.
12614	RecordDecl CFError = nullptr*;
12615	bool isCFError(RecordDecl *D);
12616
12617	/// Retrieve the identifier "NSError".
12618	IdentifierInfo *getNSErrorIdent();
12619
12620	/// Retrieve the parser's current scope.
12621	///
12622	/// This routine must only be used when it is certain that semantic analysis
12623	/// and the parser are in precisely the same context, which is not the case
12624	/// when, e.g., we are performing any kind of template instantiation.
12625	/// Therefore, the only safe places to use this scope are in the parser
12626	/// itself and in routines directly invoked from the parser and never* from*
12627	/// template substitution or instantiation.
12628	Scope getCurScope() const* { return CurScope; }
12629
12630	void incrementMSManglingNumber() const {
12631	return CurScope->incrementMSManglingNumber();
12632	}
12633
12634	IdentifierInfo getSuperIdentifier() const*;
12635	IdentifierInfo getFloat128Identifier() const*;
12636
12637	Decl getObjCDeclContext() const*;
12638
12639	DeclContext getCurLexicalContext() const* {
12640	return OriginalLexicalContext ? OriginalLexicalContext : CurContext;
12641	}
12642
12643	const DeclContext getCurObjCLexicalContext() const* {
12644	const DeclContext *DC = getCurLexicalContext();
12645	// A category implicitly has the attribute of the interface.
12646	if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC))
12647	DC = CatD->getClassInterface();
12648	return DC;
12649	}
12650
12651	/// Determine the number of levels of enclosing template parameters. This is
12652	/// only usable while parsing. Note that this does not include dependent
12653	/// contexts in which no template parameters have yet been declared, such as
12654	/// in a terse function template or generic lambda before the first 'auto' is
12655	/// encountered.
12656	unsigned getTemplateDepth(Scope S) const*;
12657
12658	/// To be used for checking whether the arguments being passed to
12659	/// function exceeds the number of parameters expected for it.
12660	static bool TooManyArguments(size_t NumParams, size_t NumArgs,
12661	bool PartialOverloading = false) {
12662	// We check whether we're just after a comma in code-completion.
12663	if (NumArgs > `0` && PartialOverloading)
12664	return NumArgs + `1` > NumParams; // If so, we view as an extra argument.
12665	return NumArgs > NumParams;
12666	}
12667
12668	// Emitting members of dllexported classes is delayed until the class
12669	// (including field initializers) is fully parsed.
12670	SmallVector<CXXRecordDecl*, `4`> DelayedDllExportClasses;
12671	SmallVector<CXXMethodDecl*, `4`> DelayedDllExportMemberFunctions;
12672
12673	private:
12674	int ParsingClassDepth = `0`;
12675
12676	class SavePendingParsedClassStateRAII {
12677	public:
12678	SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); }
12679
12680	~SavePendingParsedClassStateRAII() {
12681	assert(S.DelayedOverridingExceptionSpecChecks.empty() &&
12682	"there shouldn't be any pending delayed exception spec checks");
12683	assert(S.DelayedEquivalentExceptionSpecChecks.empty() &&
12684	"there shouldn't be any pending delayed exception spec checks");
12685	swapSavedState();
12686	}
12687
12688	private:
12689	Sema &S;
12690	decltype(DelayedOverridingExceptionSpecChecks)
12691	SavedOverridingExceptionSpecChecks;
12692	decltype(DelayedEquivalentExceptionSpecChecks)
12693	SavedEquivalentExceptionSpecChecks;
12694
12695	void swapSavedState() {
12696	SavedOverridingExceptionSpecChecks.swap(
12697	S.DelayedOverridingExceptionSpecChecks);
12698	SavedEquivalentExceptionSpecChecks.swap(
12699	S.DelayedEquivalentExceptionSpecChecks);
12700	}
12701	};
12702
12703	/// Helper class that collects misaligned member designations and
12704	/// their location info for delayed diagnostics.
12705	struct MisalignedMember {
12706	Expr *E;
12707	RecordDecl *RD;
12708	ValueDecl *MD;
12709	CharUnits Alignment;
12710
12711	MisalignedMember() : E(), RD(), MD(), Alignment () {}
12712	MisalignedMember(Expr E, RecordDecl RD, ValueDecl *MD,
12713	CharUnits Alignment)
12714	: E(E), RD(RD), MD(MD), Alignment (Alignment) {}
12715	explicit MisalignedMember(Expr *E)
12716	: MisalignedMember (E, nullptr, nullptr, CharUnits ()) {}
12717
12718	bool operator==(const MisalignedMember &m) { return this->E == m.E; }
12719	};
12720	/// Small set of gathered accesses to potentially misaligned members
12721	/// due to the packed attribute.
12722	SmallVector<MisalignedMember, `4`> MisalignedMembers;
12723
12724	/// Adds an expression to the set of gathered misaligned members.
12725	void AddPotentialMisalignedMembers(Expr E, RecordDecl RD, ValueDecl *MD,
12726	CharUnits Alignment);
12727
12728	public:
12729	/// Diagnoses the current set of gathered accesses. This typically
12730	/// happens at full expression level. The set is cleared after emitting the
12731	/// diagnostics.
12732	void DiagnoseMisalignedMembers();
12733
12734	/// This function checks if the expression is in the sef of potentially
12735	/// misaligned members and it is converted to some pointer type T with lower
12736	/// or equal alignment requirements. If so it removes it. This is used when
12737	/// we do not want to diagnose such misaligned access (e.g. in conversions to
12738	/// void).*
12739	void DiscardMisalignedMemberAddress(const Type T, Expr E);
12740
12741	/// This function calls Action when it determines that E designates a
12742	/// misaligned member due to the packed attribute. This is used to emit
12743	/// local diagnostics like in reference binding.
12744	void RefersToMemberWithReducedAlignment(
12745	Expr *E,
12746	llvm::function_ref<void(Expr , RecordDecl , FieldDecl *, CharUnits)>
12747	Action);
12748
12749	/// Describes the reason a calling convention specification was ignored, used
12750	/// for diagnostics.
12751	enum class CallingConventionIgnoredReason {
12752	ForThisTarget = `0`,
12753	VariadicFunction,
12754	ConstructorDestructor,
12755	BuiltinFunction
12756	};
12757	/// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12758	/// context is "used as device code".
12759	///
12760	/// - If CurLexicalContext is a kernel function or it is known that the
12761	/// function will be emitted for the device, emits the diagnostics
12762	/// immediately.
12763	/// - If CurLexicalContext is a function and we are compiling
12764	/// for the device, but we don't know that this function will be codegen'ed
12765	/// for devive yet, creates a diagnostic which is emitted if and when we
12766	/// realize that the function will be codegen'ed.
12767	///
12768	/// Example usage:
12769	///
12770	/// Diagnose __float128 type usage only from SYCL device code if the current
12771	/// target doesn't support it
12772	/// if (!S.Context.getTargetInfo().hasFloat128Type() &&
12773	/// S.getLangOpts().SYCLIsDevice)
12774	/// SYCLDiagIfDeviceCode(Loc, diag::err_type_unsupported) << "__float128";
12775	SemaDiagnosticBuilder SYCLDiagIfDeviceCode(SourceLocation Loc,
12776	unsigned DiagID);
12777
12778	/// Check whether we're allowed to call Callee from the current context.
12779	///
12780	/// - If the call is never allowed in a semantically-correct program
12781	/// emits an error and returns false.
12782	///
12783	/// - If the call is allowed in semantically-correct programs, but only if
12784	/// it's never codegen'ed, creates a deferred diagnostic to be emitted if
12785	/// and when the caller is codegen'ed, and returns true.
12786	///
12787	/// - Otherwise, returns true without emitting any diagnostics.
12788	///
12789	/// Adds Callee to DeviceCallGraph if we don't know if its caller will be
12790	/// codegen'ed yet.
12791	bool checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee);
12792	};
12793
12794	/// RAII object that enters a new expression evaluation context.
12795	class EnterExpressionEvaluationContext {
12796	Sema &Actions;
12797	bool Entered = true;
12798
12799	public:
12800	EnterExpressionEvaluationContext(
12801	Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
12802	Decl LambdaContextDecl = nullptr*,
12803	Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
12804	Sema::ExpressionEvaluationContextRecord::EK_Other,
12805	bool ShouldEnter = true)
12806	: Actions(Actions), Entered(ShouldEnter) {
12807	if (Entered)
12808	Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,
12809	ExprContext);
12810	}
12811	EnterExpressionEvaluationContext(
12812	Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
12813	Sema::ReuseLambdaContextDecl_t,
12814	Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
12815	Sema::ExpressionEvaluationContextRecord::EK_Other)
12816	: Actions(Actions) {
12817	Actions.PushExpressionEvaluationContext(
12818	NewContext, Sema::ReuseLambdaContextDecl, ExprContext);
12819	}
12820
12821	enum InitListTag { InitList };
12822	EnterExpressionEvaluationContext(Sema &Actions, InitListTag,
12823	bool ShouldEnter = true)
12824	: Actions(Actions), Entered(false) {
12825	// In C++11 onwards, narrowing checks are performed on the contents of
12826	// braced-init-lists, even when they occur within unevaluated operands.
12827	// Therefore we still need to instantiate constexpr functions used in such
12828	// a context.
12829	if (ShouldEnter && Actions.isUnevaluatedContext() &&
12830	Actions.getLangOpts().CPlusPlus11) {
12831	Actions.PushExpressionEvaluationContext(
12832	Sema::ExpressionEvaluationContext::UnevaluatedList);
12833	Entered = true;
12834	}
12835	}
12836
12837	~EnterExpressionEvaluationContext() {
12838	if (Entered)
12839	Actions.PopExpressionEvaluationContext();
12840	}
12841	};
12842
12843	DeductionFailureInfo
12844	MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK,
12845	sema::TemplateDeductionInfo &Info);
12846
12847	/// Contains a late templated function.
12848	/// Will be parsed at the end of the translation unit, used by Sema & Parser.
12849	struct LateParsedTemplate {
12850	CachedTokens Toks;
12851	/// The template function declaration to be late parsed.
12852	Decl *D;
12853	};
12854
12855	template <>
12856	void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation,
12857	PragmaMsStackAction Action,
12858	llvm::StringRef StackSlotLabel,
12859	AlignPackInfo Value);
12860
12861	} // end namespace clang
12862
12863	namespace llvm {
12864	// Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its
12865	// SourceLocation.
12866	template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> {
12867	using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc;
12868	using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>;
12869
12870	static FunctionDeclAndLoc getEmptyKey() {
12871	return {FDBaseInfo::getEmptyKey(), clang::SourceLocation ()};
12872	}
12873
12874	static FunctionDeclAndLoc getTombstoneKey() {
12875	return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation ()};
12876	}
12877
12878	static unsigned getHashValue(const FunctionDeclAndLoc &FDL) {
12879	return hash_combine(FDBaseInfo::getHashValue(FDL.FD),
12880	FDL.Loc.getHashValue());
12881	}
12882
12883	static bool isEqual(const FunctionDeclAndLoc &LHS,
12884	const FunctionDeclAndLoc &RHS) {
12885	return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc;
12886	}
12887	};
12888	} // namespace llvm
12889
12890	#endif
12891

Browse the source code of llvm/clang/include/clang/Sema/Sema.h